{-# OPTIONS --safe --cubical-compatible --guardedness --exact-split --double-check #-}
module Real.Interval.Atan.Core where
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Nat using (ℕ; zero; suc; _∸_) renaming (_+_ to _+ℕ_)
import Data.Nat.Base as NB
import Data.Nat.Properties as NP
open import Data.Product using (_×_; Σ; _,_; proj₁; proj₂)
open import Data.Rational using (ℚ; 0ℚ; 1ℚ; _≤_; _<_; _+_; _*_; _-_; ∣_∣)
renaming (-_ to neg)
open import Data.Rational.Base using (1/_; NonZero; positive)
open import Data.Rational.Properties using
(≤-refl; ≤-reflexive; ≤-trans; ≤-<-trans; <⇒≤; *-assoc; *-identityˡ
; *-identityʳ; *-zeroˡ; *-zeroʳ; *-distribˡ-+; +-identityˡ; +-identityʳ
; +-assoc; +-comm; +-mono-≤; +-monoʳ-≤; +-inverseˡ; 0≤p⇒∣p∣≡p
; ∣-p∣≡∣p∣; ∣p*q∣≡∣p∣*∣q∣; neg-distribˡ-*; neg-antimono-≤
; neg-antimono-<; <-asym; pos⇒nonZero; 1/pos⇒pos; positive⁻¹)
open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
open import Relation.Binary.PropositionalEquality using
(_≡_; refl; sym; trans; cong; subst; module ≡-Reasoning)
open ≡-Reasoning
open import Base.RationalRing using
(0≤1; 0<1; neg-involutive; neg-0; neg-sub; sub-sum-swap)
open import Real using (embed; 0<embed; embed-mono-≤; embed-mono-<; ε; CauchySeq)
open import Real.CauchyToInterval using (cauchy→realI)
open import Real.Interval using (RealI)
open import Real.Interval.Series.Bounds using (le-self-add)
open import Real.Interval.Kit using
(*-mono-≤-nonNeg; recip-antitone; strict-recip; 0≤diff)
qpow : ℚ → ℕ → ℚ
qpow x zero = 1ℚ
qpow x (suc n) = qpow x n * x
qpow-zero : (x : ℚ) → qpow x 0 ≡ 1ℚ
qpow-zero x = refl
qpow-suc : (x : ℚ) (n : ℕ) → qpow x (suc n) ≡ qpow x n * x
qpow-suc x n = refl
qpow-nonNeg : (x : ℚ) → 0ℚ ≤ x → (n : ℕ) → 0ℚ ≤ qpow x n
qpow-nonNeg x 0≤x zero = 0≤1
qpow-nonNeg x 0≤x (suc n) =
subst (λ z → z ≤ qpow x n * x) (*-zeroˡ x)
(*-mono-≤-nonNeg {a = 0ℚ} {a' = qpow x n} {b = x} {b' = x}
(≤-refl {0ℚ}) (qpow-nonNeg x 0≤x n) 0≤x (≤-refl {x}))
qpow-le-one : (x : ℚ) → 0ℚ ≤ x → x ≤ 1ℚ → (n : ℕ) → qpow x n ≤ 1ℚ
qpow-le-one x 0≤x x≤1 zero = ≤-refl {1ℚ}
qpow-le-one x 0≤x x≤1 (suc n) =
subst (λ z → qpow x n * x ≤ z) (*-identityˡ 1ℚ)
(*-mono-≤-nonNeg {a = qpow x n} {a' = 1ℚ} {b = x} {b' = 1ℚ}
(qpow-nonNeg x 0≤x n) (qpow-le-one x 0≤x x≤1 n) 0≤x x≤1)
qpow-add : (x : ℚ) (m n : ℕ) → qpow x (m +ℕ n) ≡ qpow x m * qpow x n
qpow-add x m zero = begin
qpow x (m +ℕ 0) ≡⟨ cong (qpow x) (NP.+-identityʳ m) ⟩
qpow x m ≡⟨ sym (*-identityʳ (qpow x m)) ⟩
qpow x m * 1ℚ ∎
qpow-add x m (suc n) = begin
qpow x (m +ℕ suc n) ≡⟨ cong (qpow x) (NP.+-suc m n) ⟩
qpow x (suc (m +ℕ n)) ≡⟨ qpow-suc x (m +ℕ n) ⟩
qpow x (m +ℕ n) * x ≡⟨ cong (_* x) (qpow-add x m n) ⟩
(qpow x m * qpow x n) * x ≡⟨ *-assoc (qpow x m) (qpow x n) x ⟩
qpow x m * (qpow x n * x) ≡⟨ cong (qpow x m *_) (sym (qpow-suc x n)) ⟩
qpow x m * qpow x (suc n) ∎
qpow-two : (x : ℚ) → qpow x 2 ≡ x * x
qpow-two x = cong (λ z → z * x) (*-identityˡ x)
qpow-step2 : (x : ℚ) (n : ℕ) → qpow x (suc (suc n)) ≡ qpow x n * (x * x)
qpow-step2 x n = *-assoc (qpow x n) x x
qpow-dec : (x : ℚ) → 0ℚ ≤ x → x ≤ 1ℚ → (n : ℕ)
→ qpow x (suc (suc n)) ≤ qpow x n
qpow-dec x 0≤x x≤1 n =
subst (λ z → z ≤ qpow x n) (sym (qpow-step2 x n))
(subst (λ z → qpow x n * (x * x) ≤ z) (*-identityʳ (qpow x n))
(*-mono-≤-nonNeg {a = qpow x n} {a' = qpow x n}
{b = x * x} {b' = 1ℚ}
(qpow-nonNeg x 0≤x n) (≤-refl {qpow x n})
(subst (λ z → z ≤ x * x) (*-zeroˡ x)
(*-mono-≤-nonNeg {a = 0ℚ} {a' = x} {b = x} {b' = x}
(≤-refl {0ℚ}) 0≤x 0≤x (≤-refl {x})))
(subst (λ z → x * x ≤ z) (*-identityˡ 1ℚ)
(*-mono-≤-nonNeg {a = x} {a' = 1ℚ} {b = x} {b' = 1ℚ}
0≤x x≤1 0≤x x≤1))))
idx : ℕ → ℕ
idx n = suc (n +ℕ n)
idx-suc : (n : ℕ) → idx (suc n) ≡ suc (suc (idx n))
idx-suc n = cong (λ k → suc k) (NP.+-suc (suc n) n)
idx-nz : (n : ℕ) → NonZero (embed (idx n))
idx-nz n = pos⇒nonZero (embed (idx n)) {{positive (0<embed (n +ℕ n))}}
idx-inc : (n : ℕ) → idx n NB.≤ idx (suc n)
idx-inc n =
subst (λ k → idx n NB.≤ k) (sym (idx-suc n))
(NP.≤-trans (NP.n≤1+n (idx n)) (NP.n≤1+n (suc (idx n))))
atanInv : ℕ → ℚ
atanInv n = 1/_ (embed (idx n)) {{idx-nz n}}
atanTerm : ℚ → ℕ → ℚ
atanTerm q n = qpow q (idx n) * atanInv n
atanInv-nonNeg : (n : ℕ) → 0ℚ ≤ atanInv n
atanInv-nonNeg n =
<⇒≤ (positive⁻¹ (atanInv n)
{{1/pos⇒pos (embed (idx n)) {{positive (0<embed (n +ℕ n))}}}})
atanTerm-nonNeg : (q : ℚ) (0≤q : 0ℚ ≤ q) (n : ℕ) → 0ℚ ≤ atanTerm q n
atanTerm-nonNeg q 0≤q n =
subst (λ z → z ≤ qpow q (idx n) * atanInv n) (*-zeroˡ (atanInv n))
(*-mono-≤-nonNeg {a = 0ℚ} {a' = qpow q (idx n)}
{b = atanInv n} {b' = atanInv n}
(≤-refl {0ℚ}) (qpow-nonNeg q 0≤q (idx n))
(atanInv-nonNeg n) (≤-refl {atanInv n}))
atanTerm-bound : (q : ℚ) (0≤q : 0ℚ ≤ q) (q≤1 : q ≤ 1ℚ) (n : ℕ)
→ atanTerm q n ≤ atanInv n
atanTerm-bound q 0≤q q≤1 n =
subst (λ z → atanTerm q n ≤ z) (*-identityˡ (atanInv n))
(*-mono-≤-nonNeg {a = qpow q (idx n)} {a' = 1ℚ}
{b = atanInv n} {b' = atanInv n}
(qpow-nonNeg q 0≤q (idx n)) (qpow-le-one q 0≤q q≤1 (idx n))
(atanInv-nonNeg n) (≤-refl {atanInv n}))
atanTerm-dec : (q : ℚ) (0≤q : 0ℚ ≤ q) (q≤1 : q ≤ 1ℚ) (n : ℕ)
→ atanTerm q (suc n) ≤ atanTerm q n
atanTerm-dec q 0≤q q≤1 n =
*-mono-≤-nonNeg {a = qpow q (idx (suc n))} {a' = qpow q (idx n)}
{b = atanInv (suc n)} {b' = atanInv n}
(qpow-nonNeg q 0≤q (idx (suc n)))
(subst (λ k → qpow q k ≤ qpow q (idx n)) (sym (idx-suc n))
(qpow-dec q 0≤q q≤1 (idx n)))
(atanInv-nonNeg (suc n))
(recip-antitone {a = embed (idx n)} {b = embed (idx (suc n))}
(0<embed (n +ℕ n))
(embed-mono-≤ {m = idx n} {n = idx (suc n)} (idx-inc n)))
sign : ℕ → ℚ
sign zero = 1ℚ
sign (suc n) = neg (sign n)
sign-eq : (n : ℕ) → (sign n ≡ 1ℚ) ⊎ (sign n ≡ neg 1ℚ)
sign-eq zero = inj₁ refl
sign-eq (suc n) with sign-eq n
... | inj₁ e = inj₂ (cong neg e)
... | inj₂ e = inj₁ (trans (cong neg e) (neg-involutive 1ℚ))
1≢neg1 : 1ℚ ≡ neg 1ℚ → ⊥
1≢neg1 e = <-asym (subst (λ z → 0ℚ < z) e 0<1) neg1<0
where
neg1<0 : neg 1ℚ < 0ℚ
neg1<0 = subst (λ z → neg 1ℚ < z) (sym neg-0)
(neg-antimono-< {0ℚ} {1ℚ} 0<1)
altSum : (ℕ → ℚ) → ℕ → ℚ
altSum a zero = 0ℚ
altSum a (suc d) = altSum a d + sign d * a d
altSum-suc : (a : ℕ → ℚ) (d : ℕ)
→ altSum a (suc d) ≡ altSum a d + sign d * a d
altSum-suc a d = refl
AltInfo : (a : ℕ → ℚ) (d : ℕ) → Set
AltInfo a d =
(0ℚ ≤ altSum a d) × (altSum a d ≤ a 0)
× ((sign d ≡ 1ℚ) → altSum a d + a d ≤ a 0)
× ((sign d ≡ neg 1ℚ) → a d ≤ altSum a d)
altSum-step : (a : ℕ → ℚ) (dec : ∀ n → a (suc n) ≤ a n)
(0≤a : ∀ n → 0ℚ ≤ a n) (d : ℕ)
→ AltInfo a d → AltInfo a (suc d)
altSum-step a dec 0≤a d IH with sign-eq d
... | inj₁ e1 =
let
A = proj₁ IH
C = proj₁ (proj₂ (proj₂ IH))
bp = a d
b = a (suc d)
step = trans (altSum-suc a d)
(cong (λ z → altSum a d + z)
(trans (cong (λ z → z * bp) e1) (*-identityˡ bp)))
A' = subst (λ z → 0ℚ ≤ z) (sym step)
(subst (λ z → z ≤ altSum a d + bp) (+-identityˡ 0ℚ)
(+-mono-≤ {0ℚ} {altSum a d} {0ℚ} {bp} A (0≤a d)))
B' = subst (λ z → z ≤ a 0) (sym step) (C e1)
C' = λ e → ⊥-elim (1≢neg1 (sym (trans (sym (cong neg e1)) e)))
D' = λ e →
subst (λ z → b ≤ z) (sym step)
(≤-trans (dec d)
(subst (λ z → bp ≤ z) (+-comm bp (altSum a d))
(le-self-add {p = bp} {q = altSum a d} A)))
in A' , B' , C' , D'
... | inj₂ e2 =
let
B = proj₁ (proj₂ IH)
D = proj₂ (proj₂ (proj₂ IH))
bp = a d
b = a (suc d)
negTimes = trans (cong (λ z → z * bp) e2)
(trans (sym (neg-distribˡ-* 1ℚ bp))
(cong neg (*-identityˡ bp)))
step = trans (altSum-suc a d) (cong (λ z → altSum a d + z) negTimes)
negb≤0 : neg bp ≤ 0ℚ
negb≤0 = subst (λ z → neg bp ≤ z) (sym neg-0)
(neg-antimono-≤ {0ℚ} {bp} (0≤a d))
subL : altSum a d + neg bp ≤ altSum a d
subL = ≤-trans (+-monoʳ-≤ (altSum a d) negb≤0)
(≤-reflexive (+-identityʳ (altSum a d)))
leftEq : (altSum a d + neg bp) + bp ≤ altSum a d
leftEq = ≤-trans
(≤-reflexive (+-assoc (altSum a d) (neg bp) bp))
(≤-trans
(+-monoʳ-≤ (altSum a d) (≤-reflexive (+-inverseˡ bp)))
(≤-reflexive (+-identityʳ (altSum a d))))
leftPart : (altSum a d + neg bp) + b ≤ altSum a d
leftPart = ≤-trans (+-monoʳ-≤ (altSum a d + neg bp) (dec d)) leftEq
A' = subst (λ z → 0ℚ ≤ z) (sym step)
(0≤diff {a = bp} {b = altSum a d} (D e2))
B' = subst (λ z → z ≤ a 0) (sym step) (≤-trans subL B)
C' = λ e → subst (λ z → z + b ≤ a 0) (sym step) (≤-trans leftPart B)
D' = λ e → ⊥-elim (1≢neg1
(trans (sym (trans (cong neg e2) (neg-involutive 1ℚ))) e))
in A' , B' , C' , D'
altSum-info : (a : ℕ → ℚ) (dec : ∀ n → a (suc n) ≤ a n)
(0≤a : ∀ n → 0ℚ ≤ a n) (d : ℕ) → AltInfo a d
altSum-info a dec 0≤a zero =
≤-refl {0ℚ} , 0≤a 0
, (λ e → ≤-reflexive (+-identityˡ (a 0)))
, (λ e → ⊥-elim (1≢neg1 e))
altSum-info a dec 0≤a (suc d) = altSum-step a dec 0≤a d (altSum-info a dec 0≤a d)
altSum-bounds : (a : ℕ → ℚ) (dec : ∀ n → a (suc n) ≤ a n)
(0≤a : ∀ n → 0ℚ ≤ a n) (d : ℕ)
→ (0ℚ ≤ altSum a d) × (altSum a d ≤ a 0)
altSum-bounds a dec 0≤a d =
let I = altSum-info a dec 0≤a d in proj₁ I , proj₁ (proj₂ I)
sign-add : (m n : ℕ) → sign (m +ℕ n) ≡ sign m * sign n
sign-add zero n = sym (*-identityˡ (sign n))
sign-add (suc m) n =
trans (cong neg (sign-add m n)) (neg-distribˡ-* (sign m) (sign n))
shift : (a : ℕ → ℚ) (n d : ℕ)
→ altSum a (n +ℕ d)
≡ altSum a n + sign n * altSum (λ j → a (n +ℕ j)) d
shift a n zero = begin
altSum a (n +ℕ 0) ≡⟨ cong (altSum a) (NP.+-identityʳ n) ⟩
altSum a n ≡⟨ sym (+-identityʳ (altSum a n)) ⟩
altSum a n + 0ℚ ≡⟨ cong (altSum a n +_) (sym (*-zeroʳ (sign n))) ⟩
altSum a n + sign n * 0ℚ ∎
shift a n (suc d) = begin
altSum a (n +ℕ suc d)
≡⟨ cong (altSum a) (NP.+-suc n d) ⟩
altSum a (suc (n +ℕ d))
≡⟨ altSum-suc a (n +ℕ d) ⟩
altSum a (n +ℕ d) + sign (n +ℕ d) * a (n +ℕ d)
≡⟨ cong (_+ sign (n +ℕ d) * a (n +ℕ d)) (shift a n d) ⟩
(altSum a n + sign n * altSum (λ j → a (n +ℕ j)) d)
+ sign (n +ℕ d) * a (n +ℕ d)
≡⟨ cong ((altSum a n + sign n * altSum (λ j → a (n +ℕ j)) d) +_) step2 ⟩
(altSum a n + sign n * altSum (λ j → a (n +ℕ j)) d)
+ sign n * (sign d * a (n +ℕ d))
≡⟨ +-assoc (altSum a n)
(sign n * altSum (λ j → a (n +ℕ j)) d)
(sign n * (sign d * a (n +ℕ d))) ⟩
altSum a n + (sign n * altSum (λ j → a (n +ℕ j)) d
+ sign n * (sign d * a (n +ℕ d)))
≡⟨ cong (altSum a n +_)
(sym (*-distribˡ-+ (sign n)
(altSum (λ j → a (n +ℕ j)) d)
(sign d * a (n +ℕ d)))) ⟩
altSum a n + sign n * (altSum (λ j → a (n +ℕ j)) d
+ sign d * a (n +ℕ d)) ∎
where
step2 : sign (n +ℕ d) * a (n +ℕ d) ≡ sign n * (sign d * a (n +ℕ d))
step2 = begin
sign (n +ℕ d) * a (n +ℕ d) ≡⟨ cong (_* a (n +ℕ d)) (sign-add n d) ⟩
(sign n * sign d) * a (n +ℕ d) ≡⟨ *-assoc (sign n) (sign d) (a (n +ℕ d)) ⟩
sign n * (sign d * a (n +ℕ d)) ∎
one-abs : ∣ 1ℚ ∣ ≡ 1ℚ
one-abs = 0≤p⇒∣p∣≡p {1ℚ} 0≤1
sign-abs : (n : ℕ) → ∣ sign n ∣ ≡ 1ℚ
sign-abs n with sign-eq n
... | inj₁ e = subst (λ z → ∣ z ∣ ≡ 1ℚ) (sym e) one-abs
... | inj₂ e = subst (λ z → ∣ z ∣ ≡ 1ℚ) (sym e)
(trans (∣-p∣≡∣p∣ 1ℚ) one-abs)
altSum-tail : (a : ℕ → ℚ) (dec : ∀ k → a (suc k) ≤ a k)
(0≤a : ∀ k → 0ℚ ≤ a k) (n d : ℕ)
→ ∣ altSum a (n +ℕ d) - altSum a n ∣ ≤ a n
altSum-tail a dec 0≤a n d =
let
dec' : ∀ j → a (n +ℕ suc j) ≤ a (n +ℕ j)
dec' j = subst (λ z → a z ≤ a (n +ℕ j)) (sym (NP.+-suc n j)) (dec (n +ℕ j))
I : (0ℚ ≤ altSum (λ j → a (n +ℕ j)) d)
× (altSum (λ j → a (n +ℕ j)) d ≤ a (n +ℕ 0))
I = altSum-bounds (λ j → a (n +ℕ j)) dec' (λ j → 0≤a (n +ℕ j)) d
tailEq : altSum a (n +ℕ d) - altSum a n
≡ sign n * altSum (λ j → a (n +ℕ j)) d
tailEq = trans (cong (λ z → z - altSum a n) (shift a n d))
(sub-sum-swap (altSum a n)
(sign n * altSum (λ j → a (n +ℕ j)) d))
absEq : ∣ altSum a (n +ℕ d) - altSum a n ∣
≡ altSum (λ j → a (n +ℕ j)) d
absEq = trans (cong ∣_∣ tailEq)
(trans (∣p*q∣≡∣p∣*∣q∣ (sign n) (altSum (λ j → a (n +ℕ j)) d))
(trans (cong (_* ∣ altSum (λ j → a (n +ℕ j)) d ∣) (sign-abs n))
(trans (*-identityˡ ∣ altSum (λ j → a (n +ℕ j)) d ∣)
(0≤p⇒∣p∣≡p (proj₁ I)))))
bound : altSum (λ j → a (n +ℕ j)) d ≤ a n
bound = subst (λ z → altSum (λ j → a (n +ℕ j)) d ≤ z)
(cong (λ k → a k) (NP.+-identityʳ n)) (proj₂ I)
in subst (λ z → z ≤ a n) (sym absEq) bound
atanInv-lt-ε : (k n : ℕ) → suc k NB.≤ n → atanInv n < ε k
atanInv-lt-ε k n k≤n =
let
hLt : suc k NB.< idx n
hLt = NP.≤-trans (NB.s≤s k≤n) (NB.s≤s (NP.m≤m+n n n))
in strict-recip (embed (suc k)) (embed (idx n)) (0<embed k)
(embed-mono-< hLt)
atan-pair : (q : ℚ) (0≤q : 0ℚ ≤ q) (q≤1 : q ≤ 1ℚ) (k n m : ℕ)
→ suc k NB.≤ n → suc k NB.≤ m
→ ∣ altSum (atanTerm q) n - altSum (atanTerm q) m ∣ < ε k
atan-pair q 0≤q q≤1 k n m n≥ m≥ with NP.≤-total n m
... | inj₁ n≤m =
let
e : n +ℕ (m ∸ n) ≡ m
e = NP.m+[n∸m]≡n {n} {m} n≤m
tail : ∣ altSum (atanTerm q) (n +ℕ (m ∸ n)) - altSum (atanTerm q) n ∣
≤ atanTerm q n
tail = altSum-tail (atanTerm q) (atanTerm-dec q 0≤q q≤1)
(atanTerm-nonNeg q 0≤q) n (m ∸ n)
atM : ∣ altSum (atanTerm q) m - altSum (atanTerm q) n ∣ ≤ atanTerm q n
atM = subst (λ z → ∣ z - altSum (atanTerm q) n ∣ ≤ atanTerm q n)
(cong (altSum (atanTerm q)) e) tail
left : ∣ altSum (atanTerm q) m - altSum (atanTerm q) n ∣ < ε k
left = ≤-<-trans atM
(≤-<-trans (atanTerm-bound q 0≤q q≤1 n) (atanInv-lt-ε k n n≥))
absEq : ∣ altSum (atanTerm q) m - altSum (atanTerm q) n ∣
≡ ∣ altSum (atanTerm q) n - altSum (atanTerm q) m ∣
absEq = trans
(cong ∣_∣
(sym (neg-sub (altSum (atanTerm q) n) (altSum (atanTerm q) m))))
(∣-p∣≡∣p∣ (altSum (atanTerm q) n - altSum (atanTerm q) m))
in subst (λ z → z < ε k) absEq left
... | inj₂ m≤n =
let
e : m +ℕ (n ∸ m) ≡ n
e = NP.m+[n∸m]≡n {m} {n} m≤n
tail : ∣ altSum (atanTerm q) (m +ℕ (n ∸ m)) - altSum (atanTerm q) m ∣
≤ atanTerm q m
tail = altSum-tail (atanTerm q) (atanTerm-dec q 0≤q q≤1)
(atanTerm-nonNeg q 0≤q) m (n ∸ m)
in ≤-<-trans
(subst (λ z → ∣ z - altSum (atanTerm q) m ∣ ≤ atanTerm q m)
(cong (altSum (atanTerm q)) e) tail)
(≤-<-trans (atanTerm-bound q 0≤q q≤1 m) (atanInv-lt-ε k m m≥))
atan-cauchy : (q : ℚ) (0≤q : 0ℚ ≤ q) (q≤1 : q ≤ 1ℚ) (k : ℕ)
→ Σ ℕ (λ N → ∀ n m → N NB.≤ n → N NB.≤ m
→ ∣ altSum (atanTerm q) n - altSum (atanTerm q) m ∣
< ε k)
atan-cauchy q 0≤q q≤1 k =
suc k , λ n m n≥ m≥ → atan-pair q 0≤q q≤1 k n m n≥ m≥
atanSeq : (q : ℚ) (0≤q : 0ℚ ≤ q) (q≤1 : q ≤ 1ℚ) → CauchySeq
atanSeq q 0≤q q≤1 = record
{ f = λ n → altSum (atanTerm q) n
; μ = λ k → suc k
; cauchy = λ k n m n≥ m≥ → atan-pair q 0≤q q≤1 k n m n≥ m≥
}
atanq : (q : ℚ) (0≤q : 0ℚ ≤ q) (q≤1 : q ≤ 1ℚ) → RealI
atanq q 0≤q q≤1 = cauchy→realI (atanSeq q 0≤q q≤1)
atanTerm-zero : (q : ℚ) → atanTerm q 0 ≡ q
atanTerm-zero q = begin
qpow q (idx 0) * atanInv 0
≡⟨ cong (λ z → z * atanInv 0) (*-identityˡ q) ⟩
q * atanInv 0
≡⟨ *-identityʳ q ⟩
q ∎