l3lab/ntp-mathlib huggingface dataset:
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
⊢ pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i

Next tactic:
apply Quotient.induction_on_pi (p := _) γ₁
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  apply Quotient.induction_on_pi (p := _) γ₁
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
⊢ ∀ (a : (i : ι) → Path (bs i) (cs i)), (pi γ₀ ⬝ pi fun i => ⟦a i⟧) = pi fun i => γ₀ i ⬝ (fun i => ⟦a i⟧) i

Next tactic:
intro a
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  apply Quotient.induction_on_pi (p := _) γ₁
  intro a
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
a : (i : ι) → Path (bs i) (cs i)
⊢ (pi γ₀ ⬝ pi fun i => ⟦a i⟧) = pi fun i => γ₀ i ⬝ (fun i => ⟦a i⟧) i

Next tactic:
apply Quotient.induction_on_pi (p := _) γ₀
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  apply Quotient.induction_on_pi (p := _) γ₁
  intro a
  apply Quotient.induction_on_pi (p := _) γ₀
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
a : (i : ι) → Path (bs i) (cs i)
⊢ ∀ (a_1 : (i : ι) → Path (as i) (bs i)),
    ((pi fun i => ⟦a_1 i⟧) ⬝ pi fun i => ⟦a i⟧) = pi fun i => (fun i => ⟦a_1 i⟧) i ⬝ (fun i => ⟦a i⟧) i

Next tactic:
intros
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  apply Quotient.induction_on_pi (p := _) γ₁
  intro a
  apply Quotient.induction_on_pi (p := _) γ₀
  intros
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
a : (i : ι) → Path (bs i) (cs i)
a✝ : (i : ι) → Path (as i) (bs i)
⊢ ((pi fun i => ⟦a✝ i⟧) ⬝ pi fun i => ⟦a i⟧) = pi fun i => (fun i => ⟦a✝ i⟧) i ⬝ (fun i => ⟦a i⟧) i

Next tactic:
simp only [pi_lift]
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  apply Quotient.induction_on_pi (p := _) γ₁
  intro a
  apply Quotient.induction_on_pi (p := _) γ₀
  intros
  simp only [pi_lift]
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
a : (i : ι) → Path (bs i) (cs i)
a✝ : (i : ι) → Path (as i) (bs i)
⊢ ⟦Path.pi fun i => a✝ i⟧ ⬝ ⟦Path.pi fun i => a i⟧ = pi fun i => ⟦a✝ i⟧ ⬝ ⟦a i⟧

Next tactic:
rw [← Path.Homotopic.comp_lift, Path.trans_pi_eq_pi_trans, ← pi_lift]
/-- Composition and products commute.
  This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. -/
theorem comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
    (γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)): pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i := by
  apply Quotient.induction_on_pi (p := _) γ₁
  intro a
  apply Quotient.induction_on_pi (p := _) γ₀
  intros
  simp only [pi_lift]
  rw [← Path.Homotopic.comp_lift, Path.trans_pi_eq_pi_trans, ← pi_lift]
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
a : (i : ι) → Path (bs i) (cs i)
a✝ : (i : ι) → Path (as i) (bs i)
⊢ (pi fun i => ⟦Path.trans (a✝ i) (a i)⟧) = pi fun i => ⟦a✝ i⟧ ⬝ ⟦a i⟧

Next tactic:
rfl
/-- Lemmas showing projection is the inverse of pi. -/
@[simp]
theorem proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
    proj i (pi paths) = paths i := by
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
i : ι
paths : (i : ι) → Homotopic.Quotient (as i) (bs i)
⊢ proj i (pi paths) = paths i

Next tactic:
apply Quotient.induction_on_pi (p := _) paths
/-- Lemmas showing projection is the inverse of pi. -/
@[simp]
theorem proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
    proj i (pi paths) = paths i := by
  apply Quotient.induction_on_pi (p := _) paths
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
i : ι
paths : (i : ι) → Homotopic.Quotient (as i) (bs i)
⊢ ∀ (a : (i : ι) → Path (as i) (bs i)), proj i (pi fun i => ⟦a i⟧) = (fun i => ⟦a i⟧) i

Next tactic:
intro
/-- Lemmas showing projection is the inverse of pi. -/
@[simp]
theorem proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
    proj i (pi paths) = paths i := by
  apply Quotient.induction_on_pi (p := _) paths
  intro; 

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
i : ι
paths : (i : ι) → Homotopic.Quotient (as i) (bs i)
a✝ : (i : ι) → Path (as i) (bs i)
⊢ proj i (pi fun i => ⟦a✝ i⟧) = (fun i => ⟦a✝ i⟧) i

Next tactic:
unfold proj
/-- Lemmas showing projection is the inverse of pi. -/
@[simp]
theorem proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
    proj i (pi paths) = paths i := by
  apply Quotient.induction_on_pi (p := _) paths
  intro; unfold proj
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
i : ι
paths : (i : ι) → Homotopic.Quotient (as i) (bs i)
a✝ : (i : ι) → Path (as i) (bs i)
⊢ Quotient.mapFn (pi fun i => ⟦a✝ i⟧) (ContinuousMap.mk fun p => p i) = (fun i => ⟦a✝ i⟧) i

Next tactic:
rw [pi_lift, ← Path.Homotopic.map_lift]
/-- Lemmas showing projection is the inverse of pi. -/
@[simp]
theorem proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
    proj i (pi paths) = paths i := by
  apply Quotient.induction_on_pi (p := _) paths
  intro; unfold proj
  rw [pi_lift, ← Path.Homotopic.map_lift]
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
i : ι
paths : (i : ι) → Homotopic.Quotient (as i) (bs i)
a✝ : (i : ι) → Path (as i) (bs i)
⊢ ⟦Path.map (Path.pi fun i => a✝ i) (_ : Continuous ⇑(ContinuousMap.mk fun p => p i))⟧ = (fun i => ⟦a✝ i⟧) i

Next tactic:
congr
@[simp]
theorem pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
⊢ (pi fun i => proj i p) = p

Next tactic:
apply Quotient.inductionOn (motive := _) p
@[simp]
theorem pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
  apply Quotient.inductionOn (motive := _) p
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
⊢ ∀ (a : Path as bs), (pi fun i => proj i ⟦a⟧) = ⟦a⟧

Next tactic:
intro
@[simp]
theorem pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro; 

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => proj i ⟦a✝⟧) = ⟦a✝⟧

Next tactic:
unfold proj
@[simp]
theorem pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro; unfold proj
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => Quotient.mapFn ⟦a✝⟧ (ContinuousMap.mk fun p => p i)) = ⟦a✝⟧

Next tactic:
simp_rw [← Path.Homotopic.map_lift]
@[simp]
theorem pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro; unfold proj
  simp_rw [← Path.Homotopic.map_lift]
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ (pi fun i => ⟦Path.map a✝ (_ : Continuous ⇑(ContinuousMap.mk fun p => p i))⟧) = ⟦a✝⟧

Next tactic:
erw [pi_lift]
@[simp]
theorem pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro; unfold proj
  simp_rw [← Path.Homotopic.map_lift]
  erw [pi_lift]
  

Proof state:
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
a✝ : Path as bs
⊢ ⟦Path.pi fun i => Path.map a✝ (_ : Continuous ⇑(ContinuousMap.mk fun p => p i))⟧ = ⟦a✝⟧

Next tactic:
congr
/-- Products commute with path composition.
    This is `trans_prod_eq_prod_trans` descended to the quotient.-/
theorem comp_prod_eq_prod_comp : prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
⊢ prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂)

Next tactic:
apply Quotient.inductionOn₂ (motive := _) q₁ q₂
/-- Products commute with path composition.
    This is `trans_prod_eq_prod_trans` descended to the quotient.-/
theorem comp_prod_eq_prod_comp : prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂) := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
⊢ ∀ (a : Path a₁ a₂) (b : Path b₁ b₂), prod ⟦a⟧ ⟦b⟧ ⬝ prod r₁ r₂ = prod (⟦a⟧ ⬝ r₁) (⟦b⟧ ⬝ r₂)

Next tactic:
intro a b
/-- Products commute with path composition.
    This is `trans_prod_eq_prod_trans` descended to the quotient.-/
theorem comp_prod_eq_prod_comp : prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂) := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro a b
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
a : Path a₁ a₂
b : Path b₁ b₂
⊢ prod ⟦a⟧ ⟦b⟧ ⬝ prod r₁ r₂ = prod (⟦a⟧ ⬝ r₁) (⟦b⟧ ⬝ r₂)

Next tactic:
apply Quotient.inductionOn₂ (motive := _) r₁ r₂
/-- Products commute with path composition.
    This is `trans_prod_eq_prod_trans` descended to the quotient.-/
theorem comp_prod_eq_prod_comp : prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂) := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro a b
  apply Quotient.inductionOn₂ (motive := _) r₁ r₂
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
a : Path a₁ a₂
b : Path b₁ b₂
⊢ ∀ (a_1 : Path a₂ a₃) (b_1 : Path b₂ b₃), prod ⟦a⟧ ⟦b⟧ ⬝ prod ⟦a_1⟧ ⟦b_1⟧ = prod (⟦a⟧ ⬝ ⟦a_1⟧) (⟦b⟧ ⬝ ⟦b_1⟧)

Next tactic:
intros
/-- Products commute with path composition.
    This is `trans_prod_eq_prod_trans` descended to the quotient.-/
theorem comp_prod_eq_prod_comp : prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂) := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro a b
  apply Quotient.inductionOn₂ (motive := _) r₁ r₂
  intros
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
a : Path a₁ a₂
b : Path b₁ b₂
a✝ : Path a₂ a₃
b✝ : Path b₂ b₃
⊢ prod ⟦a⟧ ⟦b⟧ ⬝ prod ⟦a✝⟧ ⟦b✝⟧ = prod (⟦a⟧ ⬝ ⟦a✝⟧) (⟦b⟧ ⬝ ⟦b✝⟧)

Next tactic:
simp only [prod_lift, ← Path.Homotopic.comp_lift, Path.trans_prod_eq_prod_trans]
/-- Lemmas showing projection is the inverse of product. -/
@[simp]
theorem projLeft_prod : projLeft (prod q₁ q₂) = q₁ := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
⊢ projLeft (prod q₁ q₂) = q₁

Next tactic:
apply Quotient.inductionOn₂ (motive := _) q₁ q₂
/-- Lemmas showing projection is the inverse of product. -/
@[simp]
theorem projLeft_prod : projLeft (prod q₁ q₂) = q₁ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
⊢ ∀ (a : Path a₁ a₂) (b : Path b₁ b₂), projLeft (prod ⟦a⟧ ⟦b⟧) = ⟦a⟧

Next tactic:
intro p₁ p₂
/-- Lemmas showing projection is the inverse of product. -/
@[simp]
theorem projLeft_prod : projLeft (prod q₁ q₂) = q₁ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro p₁ p₂
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁✝ p₁' : Path a₁ a₂
p₂✝ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p₁ : Path a₁ a₂
p₂ : Path b₁ b₂
⊢ projLeft (prod ⟦p₁⟧ ⟦p₂⟧) = ⟦p₁⟧

Next tactic:
unfold projLeft
/-- Lemmas showing projection is the inverse of product. -/
@[simp]
theorem projLeft_prod : projLeft (prod q₁ q₂) = q₁ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro p₁ p₂
  unfold projLeft
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁✝ p₁' : Path a₁ a₂
p₂✝ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p₁ : Path a₁ a₂
p₂ : Path b₁ b₂
⊢ Quotient.mapFn (prod ⟦p₁⟧ ⟦p₂⟧) (ContinuousMap.mk Prod.fst) = ⟦p₁⟧

Next tactic:
rw [prod_lift, ← Path.Homotopic.map_lift]
/-- Lemmas showing projection is the inverse of product. -/
@[simp]
theorem projLeft_prod : projLeft (prod q₁ q₂) = q₁ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro p₁ p₂
  unfold projLeft
  rw [prod_lift, ← Path.Homotopic.map_lift]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁✝ p₁' : Path a₁ a₂
p₂✝ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p₁ : Path a₁ a₂
p₂ : Path b₁ b₂
⊢ ⟦Path.map (Path.prod p₁ p₂) (_ : Continuous ⇑(ContinuousMap.mk Prod.fst))⟧ = ⟦p₁⟧

Next tactic:
congr
@[simp]
theorem projRight_prod : projRight (prod q₁ q₂) = q₂ := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
⊢ projRight (prod q₁ q₂) = q₂

Next tactic:
apply Quotient.inductionOn₂ (motive := _) q₁ q₂
@[simp]
theorem projRight_prod : projRight (prod q₁ q₂) = q₂ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
⊢ ∀ (a : Path a₁ a₂) (b : Path b₁ b₂), projRight (prod ⟦a⟧ ⟦b⟧) = ⟦b⟧

Next tactic:
intro p₁ p₂
@[simp]
theorem projRight_prod : projRight (prod q₁ q₂) = q₂ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro p₁ p₂
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁✝ p₁' : Path a₁ a₂
p₂✝ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p₁ : Path a₁ a₂
p₂ : Path b₁ b₂
⊢ projRight (prod ⟦p₁⟧ ⟦p₂⟧) = ⟦p₂⟧

Next tactic:
unfold projRight
@[simp]
theorem projRight_prod : projRight (prod q₁ q₂) = q₂ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro p₁ p₂
  unfold projRight
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁✝ p₁' : Path a₁ a₂
p₂✝ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p₁ : Path a₁ a₂
p₂ : Path b₁ b₂
⊢ Quotient.mapFn (prod ⟦p₁⟧ ⟦p₂⟧) (ContinuousMap.mk Prod.snd) = ⟦p₂⟧

Next tactic:
rw [prod_lift, ← Path.Homotopic.map_lift]
@[simp]
theorem projRight_prod : projRight (prod q₁ q₂) = q₂ := by
  apply Quotient.inductionOn₂ (motive := _) q₁ q₂
  intro p₁ p₂
  unfold projRight
  rw [prod_lift, ← Path.Homotopic.map_lift]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁✝ p₁' : Path a₁ a₂
p₂✝ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p₁ : Path a₁ a₂
p₂ : Path b₁ b₂
⊢ ⟦Path.map (Path.prod p₁ p₂) (_ : Continuous ⇑(ContinuousMap.mk Prod.snd))⟧ = ⟦p₂⟧

Next tactic:
congr
@[simp]
theorem prod_projLeft_projRight (p : Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂)) :
    prod (projLeft p) (projRight p) = p := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
⊢ prod (projLeft p) (projRight p) = p

Next tactic:
apply Quotient.inductionOn (motive := _) p
@[simp]
theorem prod_projLeft_projRight (p : Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂)) :
    prod (projLeft p) (projRight p) = p := by
  apply Quotient.inductionOn (motive := _) p
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
⊢ ∀ (a : Path (a₁, b₁) (a₂, b₂)), prod (projLeft ⟦a⟧) (projRight ⟦a⟧) = ⟦a⟧

Next tactic:
intro p'
@[simp]
theorem prod_projLeft_projRight (p : Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂)) :
    prod (projLeft p) (projRight p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro p'
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
p' : Path (a₁, b₁) (a₂, b₂)
⊢ prod (projLeft ⟦p'⟧) (projRight ⟦p'⟧) = ⟦p'⟧

Next tactic:
unfold projLeft
@[simp]
theorem prod_projLeft_projRight (p : Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂)) :
    prod (projLeft p) (projRight p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro p'
  unfold projLeft; 

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
p' : Path (a₁, b₁) (a₂, b₂)
⊢ prod (Quotient.mapFn ⟦p'⟧ (ContinuousMap.mk Prod.fst)) (projRight ⟦p'⟧) = ⟦p'⟧

Next tactic:
unfold projRight
@[simp]
theorem prod_projLeft_projRight (p : Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂)) :
    prod (projLeft p) (projRight p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro p'
  unfold projLeft; unfold projRight
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
p' : Path (a₁, b₁) (a₂, b₂)
⊢ prod (Quotient.mapFn ⟦p'⟧ (ContinuousMap.mk Prod.fst)) (Quotient.mapFn ⟦p'⟧ (ContinuousMap.mk Prod.snd)) = ⟦p'⟧

Next tactic:
simp only [← Path.Homotopic.map_lift, prod_lift]
@[simp]
theorem prod_projLeft_projRight (p : Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂)) :
    prod (projLeft p) (projRight p) = p := by
  apply Quotient.inductionOn (motive := _) p
  intro p'
  unfold projLeft; unfold projRight
  simp only [← Path.Homotopic.map_lift, prod_lift]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
p' : Path (a₁, b₁) (a₂, b₂)
⊢ prod ⟦Path.map p' (_ : Continuous ⇑(ContinuousMap.mk Prod.fst))⟧
      ⟦Path.map p' (_ : Continuous ⇑(ContinuousMap.mk Prod.snd))⟧ =
    ⟦p'⟧

Next tactic:
congr
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
⊢ (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support

Next tactic:
intro a h