[GOAL]
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : CommSemigroup β
f : α → β
n m : α
⊢ f (min n m) * f (max n m) = f n * f m
[PROOFSTEP]
cases' le_total n m with h h
[GOAL]
case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : CommSemigroup β
f : α → β
n m : α
h : n ≤ m
⊢ f (min n m) * f (max n m) = f n * f m
[PROOFSTEP]
simp [h, mul_comm]
[GOAL]
case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : CommSemigroup β
f : α → β
n m : α
h : m ≤ n
⊢ f (min n m) * f (max n m) = f n * f m
[PROOFSTEP]
simp [h, mul_comm]
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a₁ a₂ b₁ b₂ : α
⊢ a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂
[PROOFSTEP]
contrapose!
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a₁ a₂ b₁ b₂ : α
⊢ a₂ ≤ a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ ≤ a₁ * b₁
[PROOFSTEP]
exact fun h => mul_le_mul' h.1 h.2
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
⊢ a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂
[PROOFSTEP]
contrapose!
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
⊢ a₂ < a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ < a₁ * b₁
[PROOFSTEP]
exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a₁ a₂ b₁ b₂ : α
⊢ a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂
[PROOFSTEP]
contrapose!
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a₁ a₂ b₁ b₂ : α
⊢ a₂ ≤ a₁ ∧ b₂ < b₁ → a₂ * b₂ < a₁ * b₁
[PROOFSTEP]
exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
⊢ a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂
[PROOFSTEP]
contrapose!
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
⊢ a₂ < a₁ ∧ b₂ < b₁ → a₂ * b₂ < a₁ * b₁
[PROOFSTEP]
exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
[GOAL]
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
⊢ a₁ * b₁ < a₂ * b₂ ↔ a₁ < a₂ ∨ b₁ < b₂
[PROOFSTEP]
refine' ⟨lt_or_lt_of_mul_lt_mul, fun h => _⟩
[GOAL]
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
h : a₁ < a₂ ∨ b₁ < b₂
⊢ a₁ * b₁ < a₂ * b₂
[PROOFSTEP]
cases' h with ha' hb'
[GOAL]
case inl
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
ha' : a₁ < a₂
⊢ a₁ * b₁ < a₂ * b₂
[PROOFSTEP]
exact mul_lt_mul_of_lt_of_le ha' hb
[GOAL]
case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : Mul α
inst✝³ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
ha : a₁ ≤ a₂
hb : b₁ ≤ b₂
hb' : b₁ < b₂
⊢ a₁ * b₁ < a₂ * b₂
[PROOFSTEP]
exact mul_lt_mul_of_le_of_lt ha hb'


[GOAL]
α β : BoolAlgCat
e : ↑α ≃o ↑β
⊢ ((let src :=
        { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
          map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑e,
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑α),
                      SupHom.toFun
                          { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                              map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑α),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) }) ≫
      let src :=
        {
          toSupHom :=
            { toFun := ↑(OrderIso.symm e),
              map_sup' :=
                (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
          map_inf' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑(OrderIso.symm e),
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑β),
                      SupHom.toFun
                          {
                              toSupHom :=
                                { toFun := ↑(OrderIso.symm e),
                                  map_sup' :=
                                    (_ :
                                      ∀ (a b : ↑β),
                                        ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                              map_inf' :=
                                (_ :
                                  ∀ (a b : ↑β),
                                    ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑β),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) }) =
    𝟙 α
[PROOFSTEP]
ext
[GOAL]
case w
α β : BoolAlgCat
e : ↑α ≃o ↑β
x✝ : (forget BoolAlgCat).obj α
⊢ ↑((let src :=
            { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
              map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑e,
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑α),
                          SupHom.toFun
                              { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                  map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑α),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) }) ≫
          let src :=
            {
              toSupHom :=
                { toFun := ↑(OrderIso.symm e),
                  map_sup' :=
                    (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
              map_inf' :=
                (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑(OrderIso.symm e),
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑β),
                          SupHom.toFun
                              {
                                  toSupHom :=
                                    { toFun := ↑(OrderIso.symm e),
                                      map_sup' :=
                                        (_ :
                                          ∀ (a b : ↑β),
                                            ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                  map_inf' :=
                                    (_ :
                                      ∀ (a b : ↑β),
                                        ↑(OrderIso.symm e) (a ⊓ b) =
                                          ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑β),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) })
      x✝ =
    ↑(𝟙 α) x✝
[PROOFSTEP]
exact e.symm_apply_apply _
[GOAL]
α β : BoolAlgCat
e : ↑α ≃o ↑β
⊢ ((let src :=
        {
          toSupHom :=
            { toFun := ↑(OrderIso.symm e),
              map_sup' :=
                (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
          map_inf' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑(OrderIso.symm e),
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑β),
                      SupHom.toFun
                          {
                              toSupHom :=
                                { toFun := ↑(OrderIso.symm e),
                                  map_sup' :=
                                    (_ :
                                      ∀ (a b : ↑β),
                                        ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                              map_inf' :=
                                (_ :
                                  ∀ (a b : ↑β),
                                    ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑β),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) }) ≫
      let src :=
        { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
          map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑e,
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑α),
                      SupHom.toFun
                          { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                              map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑α),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) }) =
    𝟙 β
[PROOFSTEP]
ext
[GOAL]
case w
α β : BoolAlgCat
e : ↑α ≃o ↑β
x✝ : (forget BoolAlgCat).obj β
⊢ ↑((let src :=
            {
              toSupHom :=
                { toFun := ↑(OrderIso.symm e),
                  map_sup' :=
                    (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
              map_inf' :=
                (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑(OrderIso.symm e),
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑β),
                          SupHom.toFun
                              {
                                  toSupHom :=
                                    { toFun := ↑(OrderIso.symm e),
                                      map_sup' :=
                                        (_ :
                                          ∀ (a b : ↑β),
                                            ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                  map_inf' :=
                                    (_ :
                                      ∀ (a b : ↑β),
                                        ↑(OrderIso.symm e) (a ⊓ b) =
                                          ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑β),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) }) ≫
          let src :=
            { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
              map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑e,
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑α),
                          SupHom.toFun
                              { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                  map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑α),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) })
      x✝ =
    ↑(𝟙 β) x✝
[PROOFSTEP]
exact e.apply_symm_apply _


[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
⊢ ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
    (fun {U} f => ChartedSpace.LiftProp P f) f →
      (fun {U} f => ChartedSpace.LiftProp P f) fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
[PROOFSTEP]
intro U V i f h x
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
U V : Opens ↑(TopCat.of M)
i : U ⟶ V
f : { x // x ∈ V } → M'
h : ChartedSpace.LiftProp P f
x : { x // x ∈ U }
⊢ ChartedSpace.LiftPropAt P (fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)) x
[PROOFSTEP]
have hUV : U ≤ V := CategoryTheory.leOfHom i
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
U V : Opens ↑(TopCat.of M)
i : U ⟶ V
f : { x // x ∈ V } → M'
h : ChartedSpace.LiftProp P f
x : { x // x ∈ U }
hUV : U ≤ V
⊢ ChartedSpace.LiftPropAt P (fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)) x
[PROOFSTEP]
show ChartedSpace.LiftPropAt P (f ∘ Set.inclusion hUV) x
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
U V : Opens ↑(TopCat.of M)
i : U ⟶ V
f : { x // x ∈ V } → M'
h : ChartedSpace.LiftProp P f
x : { x // x ∈ U }
hUV : U ≤ V
⊢ ChartedSpace.LiftPropAt P (f ∘ inclusion hUV) x
[PROOFSTEP]
rw [← hG.liftPropAt_iff_comp_inclusion hUV]
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
U V : Opens ↑(TopCat.of M)
i : U ⟶ V
f : { x // x ∈ V } → M'
h : ChartedSpace.LiftProp P f
x : { x // x ∈ U }
hUV : U ≤ V
⊢ ChartedSpace.LiftPropAt P f (inclusion hUV x)
[PROOFSTEP]
apply h
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
⊢ ∀ {U : Opens ↑(TopCat.of M)} (f : { x // x ∈ U } → M'),
    (∀ (x : { x // x ∈ U }),
        ∃ V x i,
          TopCat.PrelocalPredicate.pred
            { pred := fun {U} f => ChartedSpace.LiftProp P f,
              res :=
                (_ :
                  ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                    ChartedSpace.LiftProp P f →
                      ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
            fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑U) }) x)) →
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        f
[PROOFSTEP]
intro V f h x
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
⊢ ChartedSpace.LiftPropAt P f x
[PROOFSTEP]
obtain ⟨U, hxU, i, hU : ChartedSpace.LiftProp P (f ∘ i)⟩ := h x
[GOAL]
case intro.intro.intro
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
U : Opens ↑(TopCat.of M)
hxU : ↑x ∈ U
i : U ⟶ V
hU : ChartedSpace.LiftProp P (f ∘ fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) })
⊢ ChartedSpace.LiftPropAt P f x
[PROOFSTEP]
let x' : U := ⟨x, hxU⟩
[GOAL]
case intro.intro.intro
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
U : Opens ↑(TopCat.of M)
hxU : ↑x ∈ U
i : U ⟶ V
hU : ChartedSpace.LiftProp P (f ∘ fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) })
x' : { x // x ∈ U } := { val := ↑x, property := hxU }
⊢ ChartedSpace.LiftPropAt P f x
[PROOFSTEP]
have hUV : U ≤ V := CategoryTheory.leOfHom i
[GOAL]
case intro.intro.intro
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
U : Opens ↑(TopCat.of M)
hxU : ↑x ∈ U
i : U ⟶ V
hU : ChartedSpace.LiftProp P (f ∘ fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) })
x' : { x // x ∈ U } := { val := ↑x, property := hxU }
hUV : U ≤ V
⊢ ChartedSpace.LiftPropAt P f x
[PROOFSTEP]
have : ChartedSpace.LiftPropAt P f (inclusion hUV x') :=
  by
  rw [hG.liftPropAt_iff_comp_inclusion hUV]
  exact hU x'
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
U : Opens ↑(TopCat.of M)
hxU : ↑x ∈ U
i : U ⟶ V
hU : ChartedSpace.LiftProp P (f ∘ fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) })
x' : { x // x ∈ U } := { val := ↑x, property := hxU }
hUV : U ≤ V
⊢ ChartedSpace.LiftPropAt P f (inclusion hUV x')
[PROOFSTEP]
rw [hG.liftPropAt_iff_comp_inclusion hUV]
[GOAL]
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
U : Opens ↑(TopCat.of M)
hxU : ↑x ∈ U
i : U ⟶ V
hU : ChartedSpace.LiftProp P (f ∘ fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) })
x' : { x // x ∈ U } := { val := ↑x, property := hxU }
hUV : U ≤ V
⊢ ChartedSpace.LiftPropAt P (f ∘ inclusion hUV) x'
[PROOFSTEP]
exact hU x'
[GOAL]
case intro.intro.intro
H : Type u_1
inst✝⁵ : TopologicalSpace H
H' : Type u_2
inst✝⁴ : TopologicalSpace H'
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
M : Type u
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
hG : LocalInvariantProp G G' P
V : Opens ↑(TopCat.of M)
f : { x // x ∈ V } → M'
h :
  ∀ (x : { x // x ∈ V }),
    ∃ V_1 x i,
      TopCat.PrelocalPredicate.pred
        { pred := fun {U} f => ChartedSpace.LiftProp P f,
          res :=
            (_ :
              ∀ {U V : Opens ↑(TopCat.of M)} (i : U ⟶ V) (f : { x // x ∈ V } → M'),
                ChartedSpace.LiftProp P f →
                  ∀ (x : { x // x ∈ U }), ChartedSpace.LiftPropAt P (f ∘ inclusion (_ : U ≤ V)) x) }
        fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)
x : { x // x ∈ V }
U : Opens ↑(TopCat.of M)
hxU : ↑x ∈ U
i : U ⟶ V
hU : ChartedSpace.LiftProp P (f ∘ fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) })
x' : { x // x ∈ U } := { val := ↑x, property := hxU }
hUV : U ≤ V
this : ChartedSpace.LiftPropAt P f (inclusion hUV x')
⊢ ChartedSpace.LiftPropAt P f x
[PROOFSTEP]
convert this