l3lab/ntp-mathlib huggingface dataset:
/-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses arguments `f₁ f₂ : CircleDeg1Liftˣ`
to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem units_semiconj_of_translationNumber_eq {f₁ f₂ : CircleDeg1Liftˣ} (h : τ f₁ = τ f₂) :
    ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ :=
  have : ∀ n : Multiplicative ℤ,
      τ ((Units.coeHom _).comp (zpowersHom _ f₁) n) =
        τ ((Units.coeHom _).comp (zpowersHom _ f₂) n) := fun n ↦ by
    simp [h]
  (semiconj_of_group_action_of_forall_translationNumber_eq _ _ this).imp fun F hF => by
    

Proof state:
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
this :
  ∀ (n : Multiplicative ℤ),
    τ ((MonoidHom.comp (Units.coeHom CircleDeg1Lift) ((zpowersHom CircleDeg1Liftˣ) f₁)) n) =
      τ ((MonoidHom.comp (Units.coeHom CircleDeg1Lift) ((zpowersHom CircleDeg1Liftˣ) f₂)) n)
F : CircleDeg1Lift
hF :
  ∀ (g : Multiplicative ℤ),
    Semiconj ⇑F ⇑((MonoidHom.comp (Units.coeHom CircleDeg1Lift) ((zpowersHom CircleDeg1Liftˣ) f₁)) g)
      ⇑((MonoidHom.comp (Units.coeHom CircleDeg1Lift) ((zpowersHom CircleDeg1Liftˣ) f₂)) g)
⊢ Semiconj ⇑F ⇑↑f₁ ⇑↑f₂

Next tactic:
simpa using hF (Multiplicative.ofAdd 1)
/-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `IsUnit f₁` and `IsUnit f₂`
to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem semiconj_of_isUnit_of_translationNumber_eq {f₁ f₂ : CircleDeg1Lift} (h₁ : IsUnit f₁)
    (h₂ : IsUnit f₂) (h : τ f₁ = τ f₂) : ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ := by
  

Proof state:
f g f₁ f₂ : CircleDeg1Lift
h₁ : IsUnit f₁
h₂ : IsUnit f₂
h : τ f₁ = τ f₂
⊢ ∃ F, Semiconj ⇑F ⇑f₁ ⇑f₂

Next tactic:
rcases h₁, h₂ with ⟨⟨f₁, rfl⟩, ⟨f₂, rfl⟩⟩
/-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `IsUnit f₁` and `IsUnit f₂`
to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem semiconj_of_isUnit_of_translationNumber_eq {f₁ f₂ : CircleDeg1Lift} (h₁ : IsUnit f₁)
    (h₂ : IsUnit f₂) (h : τ f₁ = τ f₂) : ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ := by
  rcases h₁, h₂ with ⟨⟨f₁, rfl⟩, ⟨f₂, rfl⟩⟩
  

Proof state:
case intro.intro
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
⊢ ∃ F, Semiconj ⇑F ⇑↑f₁ ⇑↑f₂

Next tactic:
exact units_semiconj_of_translationNumber_eq h
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by 

Proof state:
⊢ ∀ (a b c : PUnit.{?u.2 + 1}), a * b * c = a * (b * c)

Next tactic:
intros
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; 

Proof state:
a✝ b✝ c✝ : PUnit.{?u.2 + 1}
⊢ a✝ * b✝ * c✝ = a✝ * (b✝ * c✝)

Next tactic:
rfl
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by 

Proof state:
⊢ ∀ (a : PUnit.{?u.2 + 1}), 1 * a = a

Next tactic:
intros
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; 

Proof state:
a✝ : PUnit.{?u.2 + 1}
⊢ 1 * a✝ = a✝

Next tactic:
rfl
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; rfl
  mul_one := by 

Proof state:
⊢ ∀ (a : PUnit.{?u.2 + 1}), a * 1 = a

Next tactic:
intros
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; rfl
  mul_one := by intros; 

Proof state:
a✝ : PUnit.{?u.2 + 1}
⊢ a✝ * 1 = a✝

Next tactic:
rfl
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; rfl
  mul_one := by intros; rfl
  mul_left_inv := by 

Proof state:
⊢ ∀ (a : PUnit.{?u.2 + 1}), a⁻¹ * a = 1

Next tactic:
intros
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; rfl
  mul_one := by intros; rfl
  mul_left_inv := by intros; 

Proof state:
a✝ : PUnit.{?u.2 + 1}
⊢ a✝⁻¹ * a✝ = 1

Next tactic:
rfl
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; rfl
  mul_one := by intros; rfl
  mul_left_inv := by intros; rfl
  mul_comm := by 

Proof state:
⊢ ∀ (a b : PUnit.{?u.2 + 1}), a * b = b * a

Next tactic:
intros
@[to_additive]
instance commGroup : CommGroup PUnit where
  mul _ _ := unit
  one := unit
  inv _ := unit
  div _ _ := unit
  npow _ _ := unit
  zpow _ _ := unit
  mul_assoc := by intros; rfl
  one_mul := by intros; rfl
  mul_one := by intros; rfl
  mul_left_inv := by intros; rfl
  mul_comm := by intros; 

Proof state:
a✝ b✝ : PUnit.{?u.2 + 1}
⊢ a✝ * b✝ = b✝ * a✝

Next tactic:
rfl
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
⊢ ∀ (a b c : PUnit.{?u.2170 + 1}), a * (b + c) = a * b + a * c

Next tactic:
intros
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
a✝ b✝ c✝ : PUnit.{?u.2170 + 1}
⊢ a✝ * (b✝ + c✝) = a✝ * b✝ + a✝ * c✝

Next tactic:
rfl
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; rfl
  right_distrib := by 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
⊢ ∀ (a b c : PUnit.{?u.2170 + 1}), (a + b) * c = a * c + b * c

Next tactic:
intros
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; rfl
  right_distrib := by intros; 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
a✝ b✝ c✝ : PUnit.{?u.2170 + 1}
⊢ (a✝ + b✝) * c✝ = a✝ * c✝ + b✝ * c✝

Next tactic:
rfl
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; rfl
  right_distrib := by intros; rfl
  zero_mul := by 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
⊢ ∀ (a : PUnit.{?u.2170 + 1}), 0 * a = 0

Next tactic:
intros
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; rfl
  right_distrib := by intros; rfl
  zero_mul := by intros; 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
a✝ : PUnit.{?u.2170 + 1}
⊢ 0 * a✝ = 0

Next tactic:
rfl
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; rfl
  right_distrib := by intros; rfl
  zero_mul := by intros; rfl
  mul_zero := by 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
⊢ ∀ (a : PUnit.{?u.2170 + 1}), a * 0 = 0

Next tactic:
intros
instance commRing : CommRing PUnit where
  __ := PUnit.commGroup
  __ := PUnit.addCommGroup
  left_distrib := by intros; rfl
  right_distrib := by intros; rfl
  zero_mul := by intros; rfl
  mul_zero := by intros; 

Proof state:
src✝¹ : CommGroup PUnit.{?u.2170 + 1} := commGroup
src✝ : AddCommGroup PUnit.{?u.2170 + 1} := addCommGroup
a✝ : PUnit.{?u.2170 + 1}
⊢ a✝ * 0 = 0

Next tactic:
rfl
instance cancelCommMonoidWithZero : CancelCommMonoidWithZero PUnit := by
  

Proof state:
⊢ CancelCommMonoidWithZero PUnit.{?u.3142 + 1}

Next tactic:
refine' { PUnit.commRing with .. }
instance cancelCommMonoidWithZero : CancelCommMonoidWithZero PUnit := by
  refine' { PUnit.commRing with .. }; 

Proof state:
src✝ : CommRing PUnit.{1} := commRing
⊢ ∀ {a b c : PUnit.{1}}, a ≠ 0 → a * b = a * c → b = c

Next tactic:
intros
instance cancelCommMonoidWithZero : CancelCommMonoidWithZero PUnit := by
  refine' { PUnit.commRing with .. }; intros; 

Proof state:
src✝ : CommRing PUnit.{1} := commRing
a✝² b✝ c✝ : PUnit.{1}
a✝¹ : a✝² ≠ 0
a✝ : a✝² * b✝ = a✝² * c✝
⊢ b✝ = c✝

Next tactic:
exact Subsingleton.elim _ _
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by 

Proof state:
⊢ ∀ {a b : PUnit.{1}}, a ≠ 0 → b ≠ 0 → (fun x => 1) (a * b) = (fun x => 1) a * (fun x => 1) b

Next tactic:
intros
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; 

Proof state:
a✝² b✝ : PUnit.{1}
a✝¹ : a✝² ≠ 0
a✝ : b✝ ≠ 0
⊢ (fun x => 1) (a✝² * b✝) = (fun x => 1) a✝² * (fun x => 1) b✝

Next tactic:
rfl
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by 

Proof state:
⊢ ∀ (u : PUnit.{1}ˣ), (fun x => 1) ↑u = u⁻¹

Next tactic:
intros
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; 

Proof state:
u✝ : PUnit.{1}ˣ
⊢ (fun x => 1) ↑u✝ = u✝⁻¹

Next tactic:
rfl
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by 

Proof state:
⊢ ∀ (a : PUnit.{1}), (fun x x => unit) 0 a = 0

Next tactic:
intros
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; 

Proof state:
a✝ : PUnit.{1}
⊢ (fun x x => unit) 0 a✝ = 0

Next tactic:
rfl
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; rfl
  lcm_zero_right := by 

Proof state:
⊢ ∀ (a : PUnit.{1}), (fun x x => unit) a 0 = 0

Next tactic:
intros
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; rfl
  lcm_zero_right := by intros; 

Proof state:
a✝ : PUnit.{1}
⊢ (fun x x => unit) a✝ 0 = 0

Next tactic:
rfl
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; rfl
  lcm_zero_right := by intros; rfl
  normalize_gcd := by 

Proof state:
⊢ ∀ (a b : PUnit.{1}), normalize (gcd a b) = gcd a b

Next tactic:
intros
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; rfl
  lcm_zero_right := by intros; rfl
  normalize_gcd := by intros; 

Proof state:
a✝ b✝ : PUnit.{1}
⊢ normalize (gcd a✝ b✝) = gcd a✝ b✝

Next tactic:
rfl
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; rfl
  lcm_zero_right := by intros; rfl
  normalize_gcd := by intros; rfl
  normalize_lcm := by 

Proof state:
⊢ ∀ (a b : PUnit.{1}), normalize (lcm a b) = lcm a b

Next tactic:
intros
instance normalizedGCDMonoid : NormalizedGCDMonoid PUnit where
  gcd _ _ := unit
  lcm _ _ := unit
  normUnit _ := 1
  normUnit_zero := rfl
  normUnit_mul := by intros; rfl
  normUnit_coe_units := by intros; rfl
  gcd_dvd_left _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_dvd_right _ _ := ⟨unit, Subsingleton.elim _ _⟩
  dvd_gcd {_ _} _ _ _ := ⟨unit, Subsingleton.elim _ _⟩
  gcd_mul_lcm _ _ := ⟨1, Subsingleton.elim _ _⟩
  lcm_zero_left := by intros; rfl
  lcm_zero_right := by intros; rfl
  normalize_gcd := by intros; rfl
  normalize_lcm := by intros; 

Proof state:
a✝ b✝ : PUnit.{1}
⊢ normalize (lcm a✝ b✝) = lcm a✝ b✝

Next tactic:
rfl
instance canonicallyOrderedAddCommMonoid : CanonicallyOrderedAddCommMonoid PUnit := by
  

Proof state:
⊢ CanonicallyOrderedAddCommMonoid PUnit.{?u.6058 + 1}

Next tactic:
refine'
    { PUnit.commRing, PUnit.completeBooleanAlgebra with
      exists_add_of_le := fun {_ _} _ => ⟨unit, Subsingleton.elim _ _⟩.. }
instance canonicallyOrderedAddCommMonoid : CanonicallyOrderedAddCommMonoid PUnit := by
  refine'
    { PUnit.commRing, PUnit.completeBooleanAlgebra with
      exists_add_of_le := fun {_ _} _ => ⟨unit, Subsingleton.elim _ _⟩.. } <;>
    

Proof state:
case refine'_1
src✝¹ : CommRing PUnit.{?u.6068 + 1} := commRing
src✝ : CompleteBooleanAlgebra PUnit.{?u.6068 + 1} := completeBooleanAlgebra
⊢ ∀ (a b : PUnit.{?u.6068 + 1}), a ≤ b → ∀ (c : PUnit.{?u.6068 + 1}), c + a ≤ c + b

Next tactic:
intros
instance canonicallyOrderedAddCommMonoid : CanonicallyOrderedAddCommMonoid PUnit := by
  refine'
    { PUnit.commRing, PUnit.completeBooleanAlgebra with
      exists_add_of_le := fun {_ _} _ => ⟨unit, Subsingleton.elim _ _⟩.. } <;>
    

Proof state:
case refine'_2
src✝¹ : CommRing PUnit.{?u.6068 + 1} := commRing
src✝ : CompleteBooleanAlgebra PUnit.{?u.6068 + 1} := completeBooleanAlgebra
⊢ ∀ (a b : PUnit.{?u.6068 + 1}), a ≤ a + b

Next tactic:
intros
instance canonicallyOrderedAddCommMonoid : CanonicallyOrderedAddCommMonoid PUnit := by
  refine'
    { PUnit.commRing, PUnit.completeBooleanAlgebra with
      exists_add_of_le := fun {_ _} _ => ⟨unit, Subsingleton.elim _ _⟩.. } <;>
    intros <;>
    

Proof state:
case refine'_1
src✝¹ : CommRing PUnit.{?u.6068 + 1} := commRing
src✝ : CompleteBooleanAlgebra PUnit.{?u.6068 + 1} := completeBooleanAlgebra
a✝¹ b✝ : PUnit.{?u.6068 + 1}
a✝ : a✝¹ ≤ b✝
c✝ : PUnit.{?u.6068 + 1}
⊢ c✝ + a✝¹ ≤ c✝ + b✝

Next tactic:
trivial
instance canonicallyOrderedAddCommMonoid : CanonicallyOrderedAddCommMonoid PUnit := by
  refine'
    { PUnit.commRing, PUnit.completeBooleanAlgebra with
      exists_add_of_le := fun {_ _} _ => ⟨unit, Subsingleton.elim _ _⟩.. } <;>
    intros <;>
    

Proof state:
case refine'_2
src✝¹ : CommRing PUnit.{?u.6068 + 1} := commRing
src✝ : CompleteBooleanAlgebra PUnit.{?u.6068 + 1} := completeBooleanAlgebra
a✝ b✝ : PUnit.{?u.6068 + 1}
⊢ a✝ ≤ a✝ + b✝

Next tactic:
trivial
instance linearOrderedCancelAddCommMonoid : LinearOrderedCancelAddCommMonoid PUnit where
  __ := PUnit.canonicallyOrderedAddCommMonoid
  __ := PUnit.linearOrder
  le_of_add_le_add_left _ _ _ _ := trivial
  add_le_add_left := by 

Proof state:
src✝¹ : CanonicallyOrderedAddCommMonoid PUnit.{?u.7525 + 1} := canonicallyOrderedAddCommMonoid
src✝ : LinearOrder PUnit.{?u.7525 + 1} := linearOrder
⊢ ∀ (a b : PUnit.{?u.7525 + 1}), a ≤ b → ∀ (c : PUnit.{?u.7525 + 1}), c + a ≤ c + b

Next tactic:
intros
instance linearOrderedCancelAddCommMonoid : LinearOrderedCancelAddCommMonoid PUnit where
  __ := PUnit.canonicallyOrderedAddCommMonoid
  __ := PUnit.linearOrder
  le_of_add_le_add_left _ _ _ _ := trivial
  add_le_add_left := by intros; 

Proof state:
src✝¹ : CanonicallyOrderedAddCommMonoid PUnit.{?u.7525 + 1} := canonicallyOrderedAddCommMonoid
src✝ : LinearOrder PUnit.{?u.7525 + 1} := linearOrder
a✝¹ b✝ : PUnit.{?u.7525 + 1}
a✝ : a✝¹ ≤ b✝
c✝ : PUnit.{?u.7525 + 1}
⊢ c✝ + a✝¹ ≤ c✝ + b✝

Next tactic:
rfl
instance smulWithZero [Zero R] : SMulWithZero R PUnit := by
  

Proof state:
R : Type ?u.10778
inst✝ : Zero R
⊢ SMulWithZero R PUnit.{1}

Next tactic:
refine' { PUnit.smul with .. }
instance smulWithZero [Zero R] : SMulWithZero R PUnit := by
  refine' { PUnit.smul with .. } <;> 

Proof state:
case refine'_1
R : Type ?u.10778
inst✝ : Zero R
src✝ : SMul R PUnit.{1} := smul
⊢ ∀ (a : R), a • 0 = 0

Next tactic:
intros
instance smulWithZero [Zero R] : SMulWithZero R PUnit := by
  refine' { PUnit.smul with .. } <;> 

Proof state:
case refine'_2
R : Type ?u.10778
inst✝ : Zero R
src✝ : SMul R PUnit.{1} := smul
⊢ ∀ (m : PUnit.{1}), 0 • m = 0

Next tactic:
intros
instance smulWithZero [Zero R] : SMulWithZero R PUnit := by
  refine' { PUnit.smul with .. } <;> intros <;> 

Proof state:
case refine'_1
R : Type ?u.10778
inst✝ : Zero R
src✝ : SMul R PUnit.{1} := smul
a✝ : R
⊢ a✝ • 0 = 0

Next tactic:
exact Subsingleton.elim _ _
instance smulWithZero [Zero R] : SMulWithZero R PUnit := by
  refine' { PUnit.smul with .. } <;> intros <;> 

Proof state:
case refine'_2
R : Type ?u.10778
inst✝ : Zero R
src✝ : SMul R PUnit.{1} := smul
m✝ : PUnit.{1}
⊢ 0 • m✝ = 0

Next tactic:
exact Subsingleton.elim _ _
instance mulAction [Monoid R] : MulAction R PUnit := by
  

Proof state:
R : Type ?u.11089
inst✝ : Monoid R
⊢ MulAction R PUnit.{?u.11093 + 1}

Next tactic:
refine' { PUnit.smul with .. }
instance mulAction [Monoid R] : MulAction R PUnit := by
  refine' { PUnit.smul with .. } <;> 

Proof state:
case refine'_1
R : Type ?u.11089
inst✝ : Monoid R
src✝ : SMul R PUnit.{?u.11110 + 1} := smul
⊢ ∀ (b : PUnit.{?u.11110 + 1}), 1 • b = b

Next tactic:
intros
instance mulAction [Monoid R] : MulAction R PUnit := by
  refine' { PUnit.smul with .. } <;> 

Proof state:
case refine'_2
R : Type ?u.11089
inst✝ : Monoid R
src✝ : SMul R PUnit.{?u.11110 + 1} := smul
⊢ ∀ (x y : R) (b : PUnit.{?u.11110 + 1}), (x * y) • b = x • y • b

Next tactic:
intros
instance mulAction [Monoid R] : MulAction R PUnit := by
  refine' { PUnit.smul with .. } <;> intros <;> 

Proof state:
case refine'_1
R : Type ?u.11089
inst✝ : Monoid R
src✝ : SMul R PUnit.{?u.11110 + 1} := smul
b✝ : PUnit.{?u.11110 + 1}
⊢ 1 • b✝ = b✝

Next tactic:
exact Subsingleton.elim _ _
instance mulAction [Monoid R] : MulAction R PUnit := by
  refine' { PUnit.smul with .. } <;> intros <;> 

Proof state:
case refine'_2
R : Type ?u.11089
inst✝ : Monoid R
src✝ : SMul R PUnit.{?u.11110 + 1} := smul
x✝ y✝ : R
b✝ : PUnit.{?u.11110 + 1}
⊢ (x✝ * y✝) • b✝ = x✝ • y✝ • b✝

Next tactic:
exact Subsingleton.elim _ _
instance distribMulAction [Monoid R] : DistribMulAction R PUnit := by
  

Proof state:
R : Type ?u.11345
inst✝ : Monoid R
⊢ DistribMulAction R PUnit.{?u.11349 + 1}

Next tactic:
refine' { PUnit.mulAction with .. }
instance distribMulAction [Monoid R] : DistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> 

Proof state:
case refine'_1
R : Type ?u.11345
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.11455 + 1} := mulAction
⊢ ∀ (a : R), a • 0 = 0

Next tactic:
intros
instance distribMulAction [Monoid R] : DistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> 

Proof state:
case refine'_2
R : Type ?u.11345
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.11455 + 1} := mulAction
⊢ ∀ (a : R) (x y : PUnit.{?u.11455 + 1}), a • (x + y) = a • x + a • y

Next tactic:
intros
instance distribMulAction [Monoid R] : DistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> intros <;> 

Proof state:
case refine'_1
R : Type ?u.11345
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.11455 + 1} := mulAction
a✝ : R
⊢ a✝ • 0 = 0

Next tactic:
exact Subsingleton.elim _ _
instance distribMulAction [Monoid R] : DistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> intros <;> 

Proof state:
case refine'_2
R : Type ?u.11345
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.11455 + 1} := mulAction
a✝ : R
x✝ y✝ : PUnit.{?u.11455 + 1}
⊢ a✝ • (x✝ + y✝) = a✝ • x✝ + a✝ • y✝

Next tactic:
exact Subsingleton.elim _ _
instance mulDistribMulAction [Monoid R] : MulDistribMulAction R PUnit := by
  

Proof state:
R : Type ?u.11885
inst✝ : Monoid R
⊢ MulDistribMulAction R PUnit.{?u.11889 + 1}

Next tactic:
refine' { PUnit.mulAction with .. }
instance mulDistribMulAction [Monoid R] : MulDistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> 

Proof state:
case refine'_1
R : Type ?u.11885
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.12088 + 1} := mulAction
⊢ ∀ (r : R) (x y : PUnit.{?u.12088 + 1}), r • (x * y) = r • x * r • y

Next tactic:
intros
instance mulDistribMulAction [Monoid R] : MulDistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> 

Proof state:
case refine'_2
R : Type ?u.11885
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.12088 + 1} := mulAction
⊢ ∀ (r : R), r • 1 = 1

Next tactic:
intros
instance mulDistribMulAction [Monoid R] : MulDistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> intros <;> 

Proof state:
case refine'_1
R : Type ?u.11885
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.12088 + 1} := mulAction
r✝ : R
x✝ y✝ : PUnit.{?u.12088 + 1}
⊢ r✝ • (x✝ * y✝) = r✝ • x✝ * r✝ • y✝

Next tactic:
exact Subsingleton.elim _ _
instance mulDistribMulAction [Monoid R] : MulDistribMulAction R PUnit := by
  refine' { PUnit.mulAction with .. } <;> intros <;> 

Proof state:
case refine'_2
R : Type ?u.11885
inst✝ : Monoid R
src✝ : MulAction R PUnit.{?u.12088 + 1} := mulAction
r✝ : R
⊢ r✝ • 1 = 1

Next tactic:
exact Subsingleton.elim _ _
instance module [Semiring R] : Module R PUnit := by
  

Proof state:
R : Type ?u.14398
inst✝ : Semiring R
⊢ Module R PUnit.{?u.14401 + 1}

Next tactic:
refine' { PUnit.distribMulAction with .. }
instance module [Semiring R] : Module R PUnit := by
  refine' { PUnit.distribMulAction with .. } <;> 

Proof state:
case refine'_1
R : Type ?u.14398
inst✝ : Semiring R
src✝ : DistribMulAction R PUnit.{?u.14545 + 1} := distribMulAction
⊢ ∀ (r s : R) (x : PUnit.{?u.14545 + 1}), (r + s) • x = r • x + s • x

Next tactic:
intros