Theorem: Finset.min_le_card_mul
File: Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean

tactic: set x := (s, t) with hx
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card
state_after: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
x : Finset α × Finset α := (s, t)
hx : x = (s, t)
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card

tactic: clear_value x
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
x : Finset α × Finset α := (s, t)
hx : x = (s, t)
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card
state_after: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
x : Finset α × Finset α
hx : x = (s, t)
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card

tactic: simp only [Prod.ext_iff] at hx
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
x : Finset α × Finset α
hx : x = (s, t)
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card
state_after: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
x : Finset α × Finset α
hx : x.1 = s ∧ x.2 = t
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card

tactic: obtain ⟨rfl, rfl⟩ := hx
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
x : Finset α × Finset α
hx : x.1 = s ∧ x.2 = t
⊢ min (minOrder α) ↑(s.card + t.card - 1) ≤ ↑(s * t).card
state_after: case intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y x : Finset α × Finset α
hs : x.1.Nonempty
ht : x.2.Nonempty
⊢ min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card

tactic: refine wellFoundedOn_devosMulRel.induction (P := fun x : Finset α × Finset α ↦
  min (minOrder α) ↑(card x.1 + card x.2 - 1) ≤ card (x.1 * x.2)) ⟨hs, ht⟩ ?_
state_before: case intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y x : Finset α × Finset α
hs : x.1.Nonempty
ht : x.2.Nonempty
⊢ min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card
state_after: case intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y x : Finset α × Finset α
hs : x.1.Nonempty
ht : x.2.Nonempty
⊢ ∀ y ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
    (∀ z ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
        DevosMulRel z y → (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) z) →
      (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) y

tactic: clear! x
state_before: case intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x✝ y x : Finset α × Finset α
hs : x.1.Nonempty
ht : x.2.Nonempty
⊢ ∀ y ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
    (∀ z ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
        DevosMulRel z y → (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) z) →
      (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) y
state_after: case intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
⊢ ∀ y ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
    (∀ z ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
        DevosMulRel z y → (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) z) →
      (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) y

tactic: rintro ⟨s, t⟩ ⟨hs, ht⟩ ih
state_before: case intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
⊢ ∀ y ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
    (∀ z ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
        DevosMulRel z y → (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) z) →
      (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) y
state_after: case intro.mk.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : (s, t).1.Nonempty
ht : (s, t).2.Nonempty
ih :
  ∀ z ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
    DevosMulRel z (s, t) → (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) z
⊢ min (minOrder α) ↑((s, t).1.card + (s, t).2.card - 1) ≤ ↑((s, t).1 * (s, t).2).card

tactic: simp only [min_le_iff, tsub_le_iff_right, Prod.forall, Set.mem_setOf_eq, and_imp,
  Nat.cast_le] at *
state_before: case intro.mk.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : (s, t).1.Nonempty
ht : (s, t).2.Nonempty
ih :
  ∀ z ∈ {x | x.1.Nonempty ∧ x.2.Nonempty},
    DevosMulRel z (s, t) → (fun x => min (minOrder α) ↑(x.1.card + x.2.card - 1) ≤ ↑(x.1 * x.2).card) z
⊢ min (minOrder α) ↑((s, t).1.card + (s, t).2.card - 1) ≤ ↑((s, t).1 * (s, t).2).card
state_after: case intro.mk.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: obtain hts | hst := lt_or_le t.card s.card
state_before: case intro.mk.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hts : t.card < s.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

case intro.mk.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: obtain ⟨a, rfl⟩ | ⟨a, ha, b, hb, hab⟩ := hs.exists_eq_singleton_or_nontrivial
state_before: case intro.mk.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inl.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
t : Finset α
ht : t.Nonempty
a : α
hs : {a}.Nonempty
ih :
  ∀ (a_1 b : Finset α),
    a_1.Nonempty →
      b.Nonempty → DevosMulRel (a_1, b) ({a}, t) → minOrder α ≤ ↑(a_1 * b).card ∨ a_1.card + b.card ≤ (a_1 * b).card + 1
hst : {a}.card ≤ t.card
⊢ minOrder α ≤ ↑({a} * t).card ∨ {a}.card + t.card ≤ ({a} * t).card + 1

case intro.mk.intro.inr.inr.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: obtain ⟨g, hg, hgs⟩ : ∃ g : α, g ≠ 1 ∧ (s ∩ op g • s).Nonempty :=
  ⟨b⁻¹ * a, inv_mul_eq_one.not.2 hab.symm, _,
    mem_inter.2 ⟨ha, mem_smul_finset.2 ⟨_, hb, by simp⟩⟩⟩
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: obtain hsg | hsg := eq_or_ne (op g • s) s
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s ≠ s
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: replace hsg : (s ∩ op g • s).card < s.card := card_lt_card ⟨inter_subset_left, fun h ↦
  hsg <| eq_of_superset_of_card_ge (h.trans inter_subset_right) (card_smul_finset _ _).le⟩
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s ≠ s
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: replace aux1 := card_mono <| mulETransformLeft.fst_mul_snd_subset g (s, t)
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: replace aux2 := card_mono <| mulETransformRight.fst_mul_snd_subset g (s, t)
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: obtain hgt | hgt := disjoint_or_nonempty_inter t (g⁻¹ • t)
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : (t ∩ g⁻¹ • t).Nonempty
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: obtain hstg | hstg := le_or_lt_of_add_le_add (MulETransform.card g (s, t)).ge
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : (t ∩ g⁻¹ • t).Nonempty
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : (t ∩ g⁻¹ • t).Nonempty
hstg : (s, t).1.card + (s, t).2.card ≤ (mulETransformLeft g (s, t)).1.card + (mulETransformLeft g (s, t)).2.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inr.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : (t ∩ g⁻¹ • t).Nonempty
hstg : (s, t).1.card + (s, t).2.card < (mulETransformRight g (s, t)).1.card + (mulETransformRight g (s, t)).2.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1

tactic: simpa only [← mul_inv_rev, add_comm, card_inv] using
  ih _ _ ht.inv hs.inv
    (devosMulRel_iff.2 <| Or.inr <| Or.inr <| by
      simpa only [← mul_inv_rev, add_comm, card_inv, true_and])
state_before: case intro.mk.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hts : t.card < s.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: no goals

tactic: simpa only [← mul_inv_rev, add_comm, card_inv, true_and]
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hts : t.card < s.card
⊢ ((t⁻¹, s⁻¹).1 * (t⁻¹, s⁻¹).2).card = ((s, t).1 * (s, t).2).card ∧
    (t⁻¹, s⁻¹).1.card + (t⁻¹, s⁻¹).2.card = (s, t).1.card + (s, t).2.card ∧ (t⁻¹, s⁻¹).1.card < (s, t).1.card
state_after: no goals

tactic: simp [add_comm]
state_before: case intro.mk.intro.inr.inl.intro
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
t : Finset α
ht : t.Nonempty
a : α
hs : {a}.Nonempty
ih :
  ∀ (a_1 b : Finset α),
    a_1.Nonempty →
      b.Nonempty → DevosMulRel (a_1, b) ({a}, t) → minOrder α ≤ ↑(a_1 * b).card ∨ a_1.card + b.card ≤ (a_1 * b).card + 1
hst : {a}.card ≤ t.card
⊢ minOrder α ≤ ↑({a} * t).card ∨ {a}.card + t.card ≤ ({a} * t).card + 1
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
⊢ op (b⁻¹ * a) • b = a
state_after: no goals

tactic: refine Or.inl ((minOrder_le_natCard (zpowers_ne_bot.2 hg) <|
  s.finite_toSet.smul_set.subset hS).trans <| WithTop.coe_le_coe.2 <|
    ((Nat.card_mono s.finite_toSet.smul_set hS).trans_eq <| ?_).trans <|
      card_le_card_mul_right _ ht)
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
hS : ↑(zpowers g) ⊆ a⁻¹ • ↑s
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
hS : ↑(zpowers g) ⊆ a⁻¹ • ↑s
⊢ Nat.card ↑(a⁻¹ • ↑s) = s.card

tactic: rw [← coe_smul_finset]
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
hS : ↑(zpowers g) ⊆ a⁻¹ • ↑s
⊢ Nat.card ↑(a⁻¹ • ↑s) = s.card
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
hS : ↑(zpowers g) ⊆ a⁻¹ • ↑s
⊢ Nat.card ↑↑(a⁻¹ • s) = s.card

tactic: simp [-coe_smul_finset]
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
hS : ↑(zpowers g) ⊆ a⁻¹ • ↑s
⊢ Nat.card ↑↑(a⁻¹ • s) = s.card
state_after: no goals

tactic: rw [← hsg, coe_smul_finset, smul_comm]
state_before: case refine_1
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
c : α
hc : (fun x => x ∈ a⁻¹ • ↑s) c
⊢ (fun x => x ∈ a⁻¹ • ↑s) (c * g)
state_after: case refine_1
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
c : α
hc : (fun x => x ∈ a⁻¹ • ↑s) c
⊢ (fun x => x ∈ op g • a⁻¹ • ↑s) (c * g)

tactic: exact Set.smul_mem_smul_set hc
state_before: case refine_1
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
c : α
hc : (fun x => x ∈ a⁻¹ • ↑s) c
⊢ (fun x => x ∈ op g • a⁻¹ • ↑s) (c * g)
state_after: no goals

tactic: simp only
state_before: case refine_2
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
c : α
hc : (fun x => x ∈ a⁻¹ • ↑s) c
⊢ (fun x => x ∈ a⁻¹ • ↑s) (c * g⁻¹)
state_after: case refine_2
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
c : α
hc : (fun x => x ∈ a⁻¹ • ↑s) c
⊢ c * g⁻¹ ∈ a⁻¹ • ↑s

tactic: rwa [← op_smul_eq_mul, op_inv, ← Set.mem_smul_set_iff_inv_smul_mem, smul_comm,
  ← coe_smul_finset, hsg]
state_before: case refine_2
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : op g • s = s
c : α
hc : (fun x => x ∈ a⁻¹ • ↑s) c
⊢ c * g⁻¹ ∈ a⁻¹ • ↑s
state_after: no goals

tactic: rw [← card_smul_finset g⁻¹ t]
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + (g⁻¹ • t).card ≤ (s * t).card + 1

tactic: refine Or.inr ((add_le_add_right hst _).trans ?_)
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + (g⁻¹ • t).card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ t.card + (g⁻¹ • t).card ≤ (s * t).card + 1

tactic: rw [← card_union_of_disjoint hgt]
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ t.card + (g⁻¹ • t).card ≤ (s * t).card + 1
state_after: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ (t ∪ g⁻¹ • t).card ≤ (s * t).card + 1

tactic: exact (card_le_card_mul_left _ hgs).trans (le_add_of_le_left aux1)
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : Disjoint t (g⁻¹ • t)
⊢ (t ∪ g⁻¹ • t).card ≤ (s * t).card + 1
state_after: no goals

tactic: exact (ih _ _ hgs (hgt.mono inter_subset_union) <| devosMulRel_of_le_of_le aux1 hstg hsg).imp
  (WithTop.coe_le_coe.2 aux1).trans' fun h ↦ hstg.trans <| h.trans <| add_le_add_right aux1 _
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inr.inl
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : (t ∩ g⁻¹ • t).Nonempty
hstg : (s, t).1.card + (s, t).2.card ≤ (mulETransformLeft g (s, t)).1.card + (mulETransformLeft g (s, t)).2.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: no goals

tactic: exact (ih _ _ (hgs.mono inter_subset_union) hgt <| devosMulRel_of_le aux2 hstg).imp
  (WithTop.coe_le_coe.2 aux2).trans' fun h ↦
    hstg.le.trans <| h.trans <| add_le_add_right aux2 _
state_before: case intro.mk.intro.inr.inr.intro.intro.intro.intro.intro.intro.inr.inr.inr
α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
hs : s.Nonempty
ht : t.Nonempty
ih :
  ∀ (a b : Finset α),
    a.Nonempty →
      b.Nonempty → DevosMulRel (a, b) (s, t) → minOrder α ≤ ↑(a * b).card ∨ a.card + b.card ≤ (a * b).card + 1
hst : s.card ≤ t.card
a : α
ha : a ∈ ↑s
b : α
hb : b ∈ ↑s
hab : a ≠ b
g : α
hg : g ≠ 1
hgs : (s ∩ op g • s).Nonempty
hsg : (s ∩ op g • s).card < s.card
aux1 : ((mulETransformLeft g (s, t)).1 * (mulETransformLeft g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
aux2 : ((mulETransformRight g (s, t)).1 * (mulETransformRight g (s, t)).2).card ≤ ((s, t).1 * (s, t).2).card
hgt : (t ∩ g⁻¹ • t).Nonempty
hstg : (s, t).1.card + (s, t).2.card < (mulETransformRight g (s, t)).1.card + (mulETransformRight g (s, t)).2.card
⊢ minOrder α ≤ ↑(s * t).card ∨ s.card + t.card ≤ (s * t).card + 1
state_after: no goals