l3lab/ntp-mathlib huggingface dataset:
/-- The Fourier integral of an `L^1` function is a continuous function. -/
theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e)
    (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
    Continuous (fourierIntegral e μ L f) := by
  apply continuous_of_dominated
  · exact fun w => ((fourier_integral_convergent_iff he hL w).mp hf).1
  · refine' fun w => ae_of_all _ fun v => _
    · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
  · exact hf.norm
  · rw [continuous_induced_rng] at he
    

Proof state:
case h_cont
𝕜 : Type u_1
inst✝¹⁴ : CommRing 𝕜
V : Type u_2
inst✝¹³ : AddCommGroup V
inst✝¹² : Module 𝕜 V
inst✝¹¹ : MeasurableSpace V
W : Type u_3
inst✝¹⁰ : AddCommGroup W
inst✝⁹ : Module 𝕜 W
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
inst✝⁶ : TopologicalSpace 𝕜
inst✝⁵ : TopologicalRing 𝕜
inst✝⁴ : TopologicalSpace V
inst✝³ : BorelSpace V
inst✝² : TopologicalSpace W
e : Multiplicative 𝕜 →* ↥𝕊
μ : Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
inst✝¹ : CompleteSpace E
inst✝ : FirstCountableTopology W
he : Continuous (Subtype.val ∘ ⇑e)
hL : Continuous fun p => (L p.1) p.2
f : V → E
hf : Integrable f
⊢ ∀ᵐ (a : V) ∂μ, Continuous fun x => ↑(e (Multiplicative.ofAdd (-(L a) x))) • f a

Next tactic:
refine' ae_of_all _ fun v => (he.comp (continuous_ofAdd.comp _)).smul continuous_const
/-- The Fourier integral of an `L^1` function is a continuous function. -/
theorem fourierIntegral_continuous [FirstCountableTopology W] (he : Continuous e)
    (hL : Continuous fun p : V × W => L p.1 p.2) {f : V → E} (hf : Integrable f μ) :
    Continuous (fourierIntegral e μ L f) := by
  apply continuous_of_dominated
  · exact fun w => ((fourier_integral_convergent_iff he hL w).mp hf).1
  · refine' fun w => ae_of_all _ fun v => _
    · rw [norm_smul, Complex.norm_eq_abs, abs_coe_circle, one_mul]
  · exact hf.norm
  · rw [continuous_induced_rng] at he
    refine' ae_of_all _ fun v => (he.comp (continuous_ofAdd.comp _)).smul continuous_const
    

Proof state:
case h_cont
𝕜 : Type u_1
inst✝¹⁴ : CommRing 𝕜
V : Type u_2
inst✝¹³ : AddCommGroup V
inst✝¹² : Module 𝕜 V
inst✝¹¹ : MeasurableSpace V
W : Type u_3
inst✝¹⁰ : AddCommGroup W
inst✝⁹ : Module 𝕜 W
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
inst✝⁶ : TopologicalSpace 𝕜
inst✝⁵ : TopologicalRing 𝕜
inst✝⁴ : TopologicalSpace V
inst✝³ : BorelSpace V
inst✝² : TopologicalSpace W
e : Multiplicative 𝕜 →* ↥𝕊
μ : Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
inst✝¹ : CompleteSpace E
inst✝ : FirstCountableTopology W
he : Continuous (Subtype.val ∘ ⇑e)
hL : Continuous fun p => (L p.1) p.2
f : V → E
hf : Integrable f
v : V
⊢ Continuous fun x => -(L v) x

Next tactic:
refine' (hL.comp (continuous_prod_mk.mpr ⟨continuous_const, continuous_id⟩)).neg
/-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
def fourierChar : Multiplicative ℝ →* 𝕊 where
  toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
  map_one' := by 

Proof state:
⊢ (fun z => expMapCircle (2 * π * Multiplicative.toAdd z)) 1 = 1

Next tactic:
simp only
/-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
def fourierChar : Multiplicative ℝ →* 𝕊 where
  toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
  map_one' := by simp only; 

Proof state:
⊢ expMapCircle (2 * π * Multiplicative.toAdd 1) = 1

Next tactic:
rw [toAdd_one, mul_zero, expMapCircle_zero]
/-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
def fourierChar : Multiplicative ℝ →* 𝕊 where
  toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
  map_one' := by simp only; rw [toAdd_one, mul_zero, expMapCircle_zero]
  map_mul' x y := by 

Proof state:
x y : Multiplicative ℝ
⊢ OneHom.toFun
      { toFun := fun z => expMapCircle (2 * π * Multiplicative.toAdd z),
        map_one' := (_ : (fun z => expMapCircle (2 * π * Multiplicative.toAdd z)) 1 = 1) }
      (x * y) =
    OneHom.toFun
        { toFun := fun z => expMapCircle (2 * π * Multiplicative.toAdd z),
          map_one' := (_ : (fun z => expMapCircle (2 * π * Multiplicative.toAdd z)) 1 = 1) }
        x *
      OneHom.toFun
        { toFun := fun z => expMapCircle (2 * π * Multiplicative.toAdd z),
          map_one' := (_ : (fun z => expMapCircle (2 * π * Multiplicative.toAdd z)) 1 = 1) }
        y

Next tactic:
simp only
/-- The standard additive character of `ℝ`, given by `fun x ↦ exp (2 * π * x * I)`. -/
def fourierChar : Multiplicative ℝ →* 𝕊 where
  toFun z := expMapCircle (2 * π * Multiplicative.toAdd z)
  map_one' := by simp only; rw [toAdd_one, mul_zero, expMapCircle_zero]
  map_mul' x y := by simp only; 

Proof state:
x y : Multiplicative ℝ
⊢ expMapCircle (2 * π * Multiplicative.toAdd (x * y)) =
    expMapCircle (2 * π * Multiplicative.toAdd x) * expMapCircle (2 * π * Multiplicative.toAdd y)

Next tactic:
rw [toAdd_mul, mul_add, expMapCircle_add]
theorem fourierChar_apply (x : ℝ) : Real.fourierChar[x] = Complex.exp (↑(2 * π * x) * Complex.I) :=
  by 

Proof state:
x : ℝ
⊢ ↑(fourierChar (Multiplicative.ofAdd x)) = Complex.exp (↑(2 * π * x) * Complex.I)

Next tactic:
rfl
theorem vector_fourierIntegral_eq_integral_exp_smul {V : Type*} [AddCommGroup V] [Module ℝ V]
    [MeasurableSpace V] {W : Type*} [AddCommGroup W] [Module ℝ W] (L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ)
    (μ : Measure V) (f : V → E) (w : W) :
    VectorFourier.fourierIntegral fourierChar μ L f w =
      ∫ v : V, Complex.exp (↑(-2 * π * L v w) * Complex.I) • f v ∂μ :=
  by 

Proof state:
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℂ E
V : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : Module ℝ V
inst✝² : MeasurableSpace V
W : Type u_3
inst✝¹ : AddCommGroup W
inst✝ : Module ℝ W
L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ
μ : Measure V
f : V → E
w : W
⊢ VectorFourier.fourierIntegral fourierChar μ L f w = ∫ (v : V), Complex.exp (↑(-2 * π * (L v) w) * Complex.I) • f v ∂μ

Next tactic:
simp_rw [VectorFourier.fourierIntegral, Real.fourierChar_apply, mul_neg, neg_mul]
theorem fourierIntegral_eq_integral_exp_smul {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
    (f : ℝ → E) (w : ℝ) :
    𝓕 f w = ∫ v : ℝ, Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v := by
  

Proof state:
E✝ : Type u_1
inst✝³ : NormedAddCommGroup E✝
inst✝² : NormedSpace ℂ E✝
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
w : ℝ
⊢ 𝓕 f w = ∫ (v : ℝ), Complex.exp (↑(-2 * π * v * w) * Complex.I) • f v

Next tactic:
simp_rw [fourierIntegral_def, Real.fourierChar_apply, mul_neg, neg_mul, mul_assoc]
theorem pow_sub₀ (a : G₀) {m n : ℕ} (ha : a ≠ 0) (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

Next tactic:
have h1 : m - n + n = m := tsub_add_cancel_of_le h
theorem pow_sub₀ (a : G₀) {m n : ℕ} (ha : a ≠ 0) (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  have h1 : m - n + n = m := tsub_add_cancel_of_le h
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
h1 : m - n + n = m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

Next tactic:
have h2 : a ^ (m - n) * a ^ n = a ^ m := by rw [← pow_add, h1]
theorem pow_sub₀ (a : G₀) {m n : ℕ} (ha : a ≠ 0) (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  have h1 : m - n + n = m := tsub_add_cancel_of_le h
  have h2 : a ^ (m - n) * a ^ n = a ^ m := by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
h1 : m - n + n = m
⊢ a ^ (m - n) * a ^ n = a ^ m

Next tactic:
rw [← pow_add, h1]
theorem pow_sub₀ (a : G₀) {m n : ℕ} (ha : a ≠ 0) (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  have h1 : m - n + n = m := tsub_add_cancel_of_le h
  have h2 : a ^ (m - n) * a ^ n = a ^ m := by rw [← pow_add, h1]
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
h1 : m - n + n = m
h2 : a ^ (m - n) * a ^ n = a ^ m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

Next tactic:
simpa only [div_eq_mul_inv] using eq_div_of_mul_eq (pow_ne_zero _ ha) h2
theorem pow_sub_of_lt (a : G₀) {m n : ℕ} (h : n < m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
h : n < m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

Next tactic:
obtain rfl | ha := eq_or_ne a 0
theorem pow_sub_of_lt (a : G₀) {m n : ℕ} (h : n < m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  obtain rfl | ha := eq_or_ne a 0
  · 

Proof state:
case inl
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m✝ n✝ m n : ℕ
h : n < m
⊢ 0 ^ (m - n) = 0 ^ m * (0 ^ n)⁻¹

Next tactic:
rw [zero_pow (tsub_pos_of_lt h), zero_pow (n.zero_le.trans_lt h), zero_mul]
theorem pow_sub_of_lt (a : G₀) {m n : ℕ} (h : n < m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ := by
  obtain rfl | ha := eq_or_ne a 0
  · rw [zero_pow (tsub_pos_of_lt h), zero_pow (n.zero_le.trans_lt h), zero_mul]
  · 

Proof state:
case inr
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
h : n < m
ha : a ≠ 0
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

Next tactic:
exact pow_sub₀ _ ha h.le
theorem inv_pow_sub₀ (ha : a ≠ 0) (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
⊢ a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n

Next tactic:
rw [pow_sub₀ _ (inv_ne_zero ha) h, inv_pow, inv_pow, inv_inv]
theorem inv_pow_sub_of_lt (a : G₀) (h : n < m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m n : ℕ
a : G₀
h : n < m
⊢ a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n

Next tactic:
rw [pow_sub_of_lt a⁻¹ h, inv_pow, inv_pow, inv_inv]
theorem zero_zpow : ∀ z : ℤ, z ≠ 0 → (0 : G₀) ^ z = 0
  | (n : ℕ), h => by
    

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℕ
h : ↑n ≠ 0
⊢ 0 ^ ↑n = 0

Next tactic:
rw [zpow_ofNat, zero_pow']
theorem zero_zpow : ∀ z : ℤ, z ≠ 0 → (0 : G₀) ^ z = 0
  | (n : ℕ), h => by
    rw [zpow_ofNat, zero_pow']
    

Proof state:
case a
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0

Next tactic:
simpa using h
theorem zero_zpow : ∀ z : ℤ, z ≠ 0 → (0 : G₀) ^ z = 0
  | (n : ℕ), h => by
    rw [zpow_ofNat, zero_pow']
    simpa using h
  | -[n+1], _ => by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℕ
x✝ : -[n+1] ≠ 0
⊢ 0 ^ -[n+1] = 0

Next tactic:
simp
theorem zero_zpow_eq (n : ℤ) : (0 : G₀) ^ n = if n = 0 then 1 else 0 := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℤ
⊢ 0 ^ n = if n = 0 then 1 else 0

Next tactic:
split_ifs with h
theorem zero_zpow_eq (n : ℤ) : (0 : G₀) ^ n = if n = 0 then 1 else 0 := by
  split_ifs with h
  · 

Proof state:
case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℤ
h : n = 0
⊢ 0 ^ n = 1

Next tactic:
rw [h, zpow_zero]
theorem zero_zpow_eq (n : ℤ) : (0 : G₀) ^ n = if n = 0 then 1 else 0 := by
  split_ifs with h
  · rw [h, zpow_zero]
  · 

Proof state:
case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℤ
h : ¬n = 0
⊢ 0 ^ n = 0

Next tactic:
rw [zero_zpow _ h]
theorem zpow_add_one₀ {a : G₀} (ha : a ≠ 0) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  | (n : ℕ) => by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℕ
⊢ a ^ (↑n + 1) = a ^ ↑n * a

Next tactic:
simp only [← Int.ofNat_succ, zpow_ofNat, pow_succ']
theorem zpow_add_one₀ {a : G₀} (ha : a ≠ 0) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  | (n : ℕ) => by simp only [← Int.ofNat_succ, zpow_ofNat, pow_succ']
  | -[0+1] => by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
⊢ a ^ (-[0+1] + 1) = a ^ -[0+1] * a

Next tactic:
erw [zpow_zero, zpow_negSucc, pow_one, inv_mul_cancel ha]
theorem zpow_add_one₀ {a : G₀} (ha : a ≠ 0) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  | (n : ℕ) => by simp only [← Int.ofNat_succ, zpow_ofNat, pow_succ']
  | -[0+1] => by erw [zpow_zero, zpow_negSucc, pow_one, inv_mul_cancel ha]
  | -[n + 1+1] => by
    

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℕ
⊢ a ^ (-[n + 1+1] + 1) = a ^ -[n + 1+1] * a

Next tactic:
rw [Int.negSucc_eq, zpow_neg, neg_add, neg_add_cancel_right, zpow_neg, ← Int.ofNat_succ,
      zpow_ofNat, zpow_ofNat, pow_succ _ (n + 1), mul_inv_rev, mul_assoc, inv_mul_cancel ha,
      mul_one]
theorem zpow_sub_one₀ {a : G₀} (ha : a ≠ 0) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ :=
  calc
    a ^ (n - 1) = a ^ (n - 1) * a * a⁻¹ := by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℤ
⊢ a ^ (n - 1) = a ^ (n - 1) * a * a⁻¹

Next tactic:
rw [mul_assoc, mul_inv_cancel ha, mul_one]
theorem zpow_sub_one₀ {a : G₀} (ha : a ≠ 0) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ :=
  calc
    a ^ (n - 1) = a ^ (n - 1) * a * a⁻¹ := by rw [mul_assoc, mul_inv_cancel ha, mul_one]
    _ = a ^ n * a⁻¹ := by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℤ
⊢ a ^ (n - 1) * a * a⁻¹ = a ^ n * a⁻¹

Next tactic:
rw [← zpow_add_one₀ ha, sub_add_cancel]
theorem zpow_add₀ {a : G₀} (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m n : ℤ
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
induction' n using Int.induction_on with n ihn n ihn
theorem zpow_add₀ {a : G₀} (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n := by
  induction' n using Int.induction_on with n ihn n ihn
  · 

Proof state:
case hz
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m : ℤ
⊢ a ^ (m + 0) = a ^ m * a ^ 0

Next tactic:
simp
theorem zpow_add₀ {a : G₀} (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n := by
  induction' n using Int.induction_on with n ihn n ihn
  · simp
  · 

Proof state:
case hp
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m : ℤ
n : ℕ
ihn : a ^ (m + ↑n) = a ^ m * a ^ ↑n
⊢ a ^ (m + (↑n + 1)) = a ^ m * a ^ (↑n + 1)

Next tactic:
simp only [← add_assoc, zpow_add_one₀ ha, ihn, mul_assoc]
theorem zpow_add₀ {a : G₀} (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n := by
  induction' n using Int.induction_on with n ihn n ihn
  · simp
  · simp only [← add_assoc, zpow_add_one₀ ha, ihn, mul_assoc]
  · 

Proof state:
case hn
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m : ℤ
n : ℕ
ihn : a ^ (m + -↑n) = a ^ m * a ^ (-↑n)
⊢ a ^ (m + (-↑n - 1)) = a ^ m * a ^ (-↑n - 1)

Next tactic:
rw [zpow_sub_one₀ ha, ← mul_assoc, ← ihn, ← zpow_sub_one₀ ha, add_sub_assoc]
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
by_cases hm : m = 0
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · 

Proof state:
case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : m = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
simp [hm]
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  

Proof state:
case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
by_cases hn : n = 0
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  by_cases hn : n = 0
  · 

Proof state:
case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : n = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
simp [hn]
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  by_cases hn : n = 0
  · simp [hn]
  

Proof state:
case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : ¬n = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
by_cases ha : a = 0
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  by_cases hn : n = 0
  · simp [hn]
  by_cases ha : a = 0
  · 

Proof state:
case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : ¬n = 0
ha : a = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
subst a
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  by_cases hn : n = 0
  · simp [hn]
  by_cases ha : a = 0
  · subst a
    

Proof state:
case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
m n : ℤ
hm : ¬m = 0
hn : ¬n = 0
h : 0 ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
⊢ 0 ^ (m + n) = 0 ^ m * 0 ^ n

Next tactic:
simp only [false_or_iff, eq_self_iff_true, not_true, Ne.def, hm, hn, false_and_iff,
      or_false_iff] at h
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  by_cases hn : n = 0
  · simp [hn]
  by_cases ha : a = 0
  · subst a
    simp only [false_or_iff, eq_self_iff_true, not_true, Ne.def, hm, hn, false_and_iff,
      or_false_iff] at h
    

Proof state:
case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
m n : ℤ
hm : ¬m = 0
hn : ¬n = 0
h : ¬m + n = 0
⊢ 0 ^ (m + n) = 0 ^ m * 0 ^ n

Next tactic:
rw [zero_zpow _ h, zero_zpow _ hm, zero_mul]
theorem zpow_add' {a : G₀} {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n := by
  by_cases hm : m = 0
  · simp [hm]
  by_cases hn : n = 0
  · simp [hn]
  by_cases ha : a = 0
  · subst a
    simp only [false_or_iff, eq_self_iff_true, not_true, Ne.def, hm, hn, false_and_iff,
      or_false_iff] at h
    rw [zero_zpow _ h, zero_zpow _ hm, zero_mul]
  · 

Proof state:
case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : ¬n = 0
ha : ¬a = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

Next tactic:
exact zpow_add₀ ha m n
theorem zpow_one_add₀ {a : G₀} (h : a ≠ 0) (i : ℤ) : a ^ (1 + i) = a * a ^ i := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
h : a ≠ 0
i : ℤ
⊢ a ^ (1 + i) = a * a ^ i

Next tactic:
rw [zpow_add₀ h, zpow_one]
theorem SemiconjBy.zpow_right₀ {a x y : G₀} (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  | (n : ℕ) => by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a x y : G₀
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ ↑n) (y ^ ↑n)

Next tactic:
simp [h.pow_right n]
theorem SemiconjBy.zpow_right₀ {a x y : G₀} (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  | (n : ℕ) => by simp [h.pow_right n]
  | -[n+1] => by 

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a x y : G₀
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ -[n+1]) (y ^ -[n+1])

Next tactic:
simp only [zpow_negSucc, (h.pow_right (n + 1)).inv_right₀]
theorem zpow_ne_zero_of_ne_zero {a : G₀} (ha : a ≠ 0) : ∀ z : ℤ, a ^ z ≠ 0
  | (_ : ℕ) => by
    

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
a✝ : ℕ
⊢ a ^ ↑a✝ ≠ 0

Next tactic:
rw [zpow_ofNat]
theorem zpow_ne_zero_of_ne_zero {a : G₀} (ha : a ≠ 0) : ∀ z : ℤ, a ^ z ≠ 0
  | (_ : ℕ) => by
    rw [zpow_ofNat]
    

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
a✝ : ℕ
⊢ a ^ a✝ ≠ 0

Next tactic:
exact pow_ne_zero _ ha
theorem zpow_ne_zero_of_ne_zero {a : G₀} (ha : a ≠ 0) : ∀ z : ℤ, a ^ z ≠ 0
  | (_ : ℕ) => by
    rw [zpow_ofNat]
    exact pow_ne_zero _ ha
  | -[_+1] => by
    

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
a✝ : ℕ
⊢ a ^ -[a✝+1] ≠ 0

Next tactic:
rw [zpow_negSucc]
theorem zpow_ne_zero_of_ne_zero {a : G₀} (ha : a ≠ 0) : ∀ z : ℤ, a ^ z ≠ 0
  | (_ : ℕ) => by
    rw [zpow_ofNat]
    exact pow_ne_zero _ ha
  | -[_+1] => by
    rw [zpow_negSucc]
    

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
a✝ : ℕ
⊢ (a ^ (a✝ + 1))⁻¹ ≠ 0

Next tactic:
exact inv_ne_zero (pow_ne_zero _ ha)
theorem zpow_sub₀ {a : G₀} (ha : a ≠ 0) (z1 z2 : ℤ) : a ^ (z1 - z2) = a ^ z1 / a ^ z2 := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
z1 z2 : ℤ
⊢ a ^ (z1 - z2) = a ^ z1 / a ^ z2

Next tactic:
rw [sub_eq_add_neg, zpow_add₀ ha, zpow_neg, div_eq_mul_inv]
theorem zpow_neg_mul_zpow_self (n : ℤ) {x : G₀} (h : x ≠ 0) : x ^ (-n) * x ^ n = 1 := by
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℤ
x : G₀
h : x ≠ 0
⊢ x ^ (-n) * x ^ n = 1

Next tactic:
rw [zpow_neg]
theorem zpow_neg_mul_zpow_self (n : ℤ) {x : G₀} (h : x ≠ 0) : x ^ (-n) * x ^ n = 1 := by
  rw [zpow_neg]
  

Proof state:
G₀ : Type u_1
inst✝ : GroupWithZero G₀
n : ℤ
x : G₀
h : x ≠ 0
⊢ (x ^ n)⁻¹ * x ^ n = 1

Next tactic:
exact inv_mul_cancel (zpow_ne_zero n h)
theorem div_sq_cancel (a b : G₀) : a ^ 2 * b / a = a * b := by
  

Proof state:
G₀ : Type u_1
inst✝ : CommGroupWithZero G₀
a b : G₀
⊢ a ^ 2 * b / a = a * b

Next tactic:
by_cases ha : a = 0
theorem div_sq_cancel (a b : G₀) : a ^ 2 * b / a = a * b := by
  by_cases ha : a = 0
  · 

Proof state:
case pos
G₀ : Type u_1
inst✝ : CommGroupWithZero G₀
a b : G₀
ha : a = 0
⊢ a ^ 2 * b / a = a * b

Next tactic:
simp [ha]
theorem div_sq_cancel (a b : G₀) : a ^ 2 * b / a = a * b := by
  by_cases ha : a = 0
  · simp [ha]
  

Proof state:
case neg
G₀ : Type u_1
inst✝ : CommGroupWithZero G₀
a b : G₀
ha : ¬a = 0
⊢ a ^ 2 * b / a = a * b

Next tactic:
rw [sq, mul_assoc, mul_div_cancel_left _ ha]
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
⊢ F.map ed.s' ≫ (((whiskering C D).obj F).obj X).hom.app (op [0]) = 𝟙 (point.obj (((whiskering C D).obj F).obj X))

Next tactic:
dsimp
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
⊢ F.map ed.s' ≫ F.map (X.hom.app (op [0])) ≫ 𝟙 (F.obj X.right) = 𝟙 (F.obj X.right)

Next tactic:
erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
⊢ (fun n => F.map (s ed n)) 0 ≫ SimplicialObject.δ (((whiskering C D).obj F).obj X).left 1 =
    (((whiskering C D).obj F).obj X).hom.app (op [0]) ≫ F.map ed.s'

Next tactic:
dsimp