l3lab/ntp-mathlib huggingface dataset:
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |

Proof state:
case some.none
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s : NonemptyInterval α
⊢ -(some s + none) = -none + -some s

Next tactic:
rfl
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> 

Proof state:
case some.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s t : NonemptyInterval α
⊢ -(some s + some t) = -some t + -some s

Next tactic:
first |rfl|exact congr_arg some (neg_add_rev _ _)
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |

Proof state:
case some.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s t : NonemptyInterval α
⊢ -(some s + some t) = -some t + -some s

Next tactic:
rfl
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|

Proof state:
case some.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s t : NonemptyInterval α
⊢ -(some s + some t) = -some t + -some s

Next tactic:
exact congr_arg some (neg_add_rev _ _)
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      

Proof state:
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s t : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
⊢ ∀ (a b : Interval α), a + b = 0 → -a = b

Next tactic:
rintro (_ | s) (_ | t) h
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        

Proof state:
case none.none
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s t : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
h : none + none = 0
⊢ -none = none

Next tactic:
first
          | cases h
          | exact congr_arg some (neg_eq_of_add_eq_zero_right <| Option.some_injective _ h)
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        first
          | 

Proof state:
case none.none
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s t : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
h : none + none = 0
⊢ -none = none

Next tactic:
cases h
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        

Proof state:
case none.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
t : NonemptyInterval α
h : none + some t = 0
⊢ -none = some t

Next tactic:
first
          | cases h
          | exact congr_arg some (neg_eq_of_add_eq_zero_right <| Option.some_injective _ h)
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        first
          | 

Proof state:
case none.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
t : NonemptyInterval α
h : none + some t = 0
⊢ -none = some t

Next tactic:
cases h
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        

Proof state:
case some.none
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s : NonemptyInterval α
h : some s + none = 0
⊢ -some s = none

Next tactic:
first
          | cases h
          | exact congr_arg some (neg_eq_of_add_eq_zero_right <| Option.some_injective _ h)
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        first
          | 

Proof state:
case some.none
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s : NonemptyInterval α
h : some s + none = 0
⊢ -some s = none

Next tactic:
cases h
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        

Proof state:
case some.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s t : NonemptyInterval α
h : some s + some t = 0
⊢ -some s = some t

Next tactic:
first
          | cases h
          | exact congr_arg some (neg_eq_of_add_eq_zero_right <| Option.some_injective _ h)
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        first
          | 

Proof state:
case some.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s t : NonemptyInterval α
h : some s + some t = 0
⊢ -some s = some t

Next tactic:
cases h
instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) :=
  { Interval.addCommMonoid with
    neg := Neg.neg
    sub := Sub.sub
    sub_eq_add_neg := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (sub_eq_add_neg _ _)
    neg_neg := by rintro (_ | s) <;> first |rfl|exact congr_arg some (neg_neg _)
    neg_add_rev := by rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (neg_add_rev _ _)
    neg_eq_of_add := by
      rintro (_ | s) (_ | t) h <;>
        first
          | cases h
          | 

Proof state:
case some.some
ι : Type u_1
α✝ : Type u_2
inst✝¹ : OrderedCommGroup α✝
s✝ t✝ : Interval α✝
α : Type u
inst✝ : OrderedAddCommGroup α
src✝ : AddCommMonoid (Interval α) := addCommMonoid
s t : NonemptyInterval α
h : some s + some t = 0
⊢ -some s = some t

Next tactic:
exact congr_arg some (neg_eq_of_add_eq_zero_right <| Option.some_injective _ h)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      

Proof state:
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ ∀ (a b : Interval α), a / b = a * b⁻¹

Next tactic:
rintro (_ | s) (_ | t)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> 

Proof state:
case none.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ none / none = none * none⁻¹

Next tactic:
first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |

Proof state:
case none.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ none / none = none * none⁻¹

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> 

Proof state:
case none.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
t : NonemptyInterval α
⊢ none / some t = none * (some t)⁻¹

Next tactic:
first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |

Proof state:
case none.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
t : NonemptyInterval α
⊢ none / some t = none * (some t)⁻¹

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> 

Proof state:
case some.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ some s / none = some s * none⁻¹

Next tactic:
first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |

Proof state:
case some.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ some s / none = some s * none⁻¹

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> 

Proof state:
case some.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s t : NonemptyInterval α
⊢ some s / some t = some s * (some t)⁻¹

Next tactic:
first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |

Proof state:
case some.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s t : NonemptyInterval α
⊢ some s / some t = some s * (some t)⁻¹

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|

Proof state:
case some.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s t : NonemptyInterval α
⊢ some s / some t = some s * (some t)⁻¹

Next tactic:
exact congr_arg some (div_eq_mul_inv _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by 

Proof state:
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ ∀ (x : Interval α), x⁻¹⁻¹ = x

Next tactic:
rintro (_ | s)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> 

Proof state:
case none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ none⁻¹⁻¹ = none

Next tactic:
first |rfl|exact congr_arg some (inv_inv _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |

Proof state:
case none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ none⁻¹⁻¹ = none

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> 

Proof state:
case some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ (some s)⁻¹⁻¹ = some s

Next tactic:
first |rfl|exact congr_arg some (inv_inv _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |

Proof state:
case some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ (some s)⁻¹⁻¹ = some s

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|

Proof state:
case some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ (some s)⁻¹⁻¹ = some s

Next tactic:
exact congr_arg some (inv_inv _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by 

Proof state:
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ ∀ (a b : Interval α), (a * b)⁻¹ = b⁻¹ * a⁻¹

Next tactic:
rintro (_ | s) (_ | t)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by rintro (_ | s) (_ | t) <;> 

Proof state:
case none.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ (none * none)⁻¹ = none⁻¹ * none⁻¹

Next tactic:
first |rfl|exact congr_arg some (mul_inv_rev _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by rintro (_ | s) (_ | t) <;> first |

Proof state:
case none.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
⊢ (none * none)⁻¹ = none⁻¹ * none⁻¹

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by rintro (_ | s) (_ | t) <;> 

Proof state:
case none.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
t : NonemptyInterval α
⊢ (none * some t)⁻¹ = (some t)⁻¹ * none⁻¹

Next tactic:
first |rfl|exact congr_arg some (mul_inv_rev _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by rintro (_ | s) (_ | t) <;> first |

Proof state:
case none.some
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t✝ : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
t : NonemptyInterval α
⊢ (none * some t)⁻¹ = (some t)⁻¹ * none⁻¹

Next tactic:
rfl
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by rintro (_ | s) (_ | t) <;> 

Proof state:
case some.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ (some s * none)⁻¹ = none⁻¹ * (some s)⁻¹

Next tactic:
first |rfl|exact congr_arg some (mul_inv_rev _ _)
@[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) :=
  { Interval.commMonoid with
    inv := Inv.inv
    div := (· / ·)
    div_eq_mul_inv := by
      rintro (_ | s) (_ | t) <;> first |rfl|exact congr_arg some (div_eq_mul_inv _ _)
    inv_inv := by rintro (_ | s) <;> first |rfl|exact congr_arg some (inv_inv _)
    mul_inv_rev := by rintro (_ | s) (_ | t) <;> first |

Proof state:
case some.none
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s✝ t : Interval α
src✝ : CommMonoid (Interval α) := commMonoid
s : NonemptyInterval α
⊢ (some s * none)⁻¹ = none⁻¹ * (some s)⁻¹

Next tactic:
rfl