File: Mathlib/LinearAlgebra/CliffordAlgebra/Grading.lean

full_name: CliffordAlgebra.evenOdd
code: /-- The even or odd submodule, defined as the supremum of the even or odd powers of
`(ι Q).range`. `evenOdd 0` is the even submodule, and `evenOdd 1` is the odd submodule. -/
def evenOdd (i : ZMod 2) : Submodule R (CliffordAlgebra Q) 
goal: Submodule R (CliffordAlgebra Q)

full_name: CliffordAlgebra.one_le_evenOdd_zero
code: theorem one_le_evenOdd_zero : 1 ≤ evenOdd Q 0 
goal: 1 ≤ CliffordAlgebra.evenOdd Q 0

full_name: CliffordAlgebra.range_ι_le_evenOdd_one
code: theorem range_ι_le_evenOdd_one : LinearMap.range (ι Q) ≤ evenOdd Q 1 
goal: LinearMap.range (CliffordAlgebra.ι Q) ≤ CliffordAlgebra.evenOdd Q 1

full_name: CliffordAlgebra.ι_mem_evenOdd_one
code: theorem ι_mem_evenOdd_one (m : M) : ι Q m ∈ evenOdd Q 1 
goal: (CliffordAlgebra.ι Q) m ∈ CliffordAlgebra.evenOdd Q 1

full_name: CliffordAlgebra.ι_mul_ι_mem_evenOdd_zero
code: theorem ι_mul_ι_mem_evenOdd_zero (m₁ m₂ : M) : ι Q m₁ * ι Q m₂ ∈ evenOdd Q 0 
goal: (CliffordAlgebra.ι Q) m₁ * (CliffordAlgebra.ι Q) m₂ ∈ CliffordAlgebra.evenOdd Q 0

full_name: CliffordAlgebra.evenOdd_mul_le
code: theorem evenOdd_mul_le (i j : ZMod 2) : evenOdd Q i * evenOdd Q j ≤ evenOdd Q (i + j) 
goal: CliffordAlgebra.evenOdd Q i * CliffordAlgebra.evenOdd Q j ≤ CliffordAlgebra.evenOdd Q (i + j)

full_name: CliffordAlgebra.evenOdd.gradedMonoid
code: instance evenOdd.gradedMonoid : SetLike.GradedMonoid (evenOdd Q) 
goal: SetLike.GradedMonoid (CliffordAlgebra.evenOdd Q)

full_name: CliffordAlgebra.GradedAlgebra.ι
code: /-- A version of `CliffordAlgebra.ι` that maps directly into the graded structure. This is
primarily an auxiliary construction used to provide `CliffordAlgebra.gradedAlgebra`. -/
-- Porting note: added `protected`
protected def GradedAlgebra.ι : M →ₗ[R] ⨁ i : ZMod 2, evenOdd Q i 
goal: M →ₗ[R] DirectSum (ZMod 2) fun i => ↥(CliffordAlgebra.evenOdd Q i)

full_name: CliffordAlgebra.GradedAlgebra.ι_apply
code: theorem GradedAlgebra.ι_apply (m : M) :
    GradedAlgebra.ι Q m = DirectSum.of (fun i => ↥(evenOdd Q i)) 1 ⟨ι Q m, ι_mem_evenOdd_one Q m⟩ 
goal: (CliffordAlgebra.GradedAlgebra.ι Q) m =
  (DirectSum.of (fun i => ↥(CliffordAlgebra.evenOdd Q i)) 1) ⟨(CliffordAlgebra.ι Q) m, ⋯⟩

full_name: CliffordAlgebra.GradedAlgebra.ι_sq_scalar
code: nonrec theorem GradedAlgebra.ι_sq_scalar (m : M) :
    GradedAlgebra.ι Q m * GradedAlgebra.ι Q m = algebraMap R _ (Q m) 
goal: (CliffordAlgebra.GradedAlgebra.ι Q) m * (CliffordAlgebra.GradedAlgebra.ι Q) m =
  (algebraMap R (DirectSum (ZMod 2) fun i => ↥(CliffordAlgebra.evenOdd Q i))) (Q m)

full_name: CliffordAlgebra.GradedAlgebra.lift_ι_eq
code: theorem GradedAlgebra.lift_ι_eq (i' : ZMod 2) (x' : evenOdd Q i') :
    -- Porting note: added a second `by apply`
    lift Q ⟨by apply GradedAlgebra.ι Q, by apply GradedAlgebra.ι_sq_scalar Q⟩ x' =
      DirectSum.of (fun i => evenOdd Q i) i' x' 
goal: ((CliffordAlgebra.lift Q) ⟨CliffordAlgebra.GradedAlgebra.ι Q, ⋯⟩) ↑x' =
  (DirectSum.of (fun i => ↥(CliffordAlgebra.evenOdd Q i)) i') x'

full_name: CliffordAlgebra.gradedAlgebra
code: /-- The clifford algebra is graded by the even and odd parts. -/
instance gradedAlgebra : GradedAlgebra (evenOdd Q) 
goal: GradedAlgebra (CliffordAlgebra.evenOdd Q)

full_name: CliffordAlgebra.iSup_ι_range_eq_top
code: theorem iSup_ι_range_eq_top : ⨆ i : ℕ, LinearMap.range (ι Q) ^ i = ⊤ 
goal: ⨆ i, LinearMap.range (CliffordAlgebra.ι Q) ^ i = ⊤

full_name: CliffordAlgebra.evenOdd_isCompl
code: theorem evenOdd_isCompl : IsCompl (evenOdd Q 0) (evenOdd Q 1) 
goal: IsCompl (CliffordAlgebra.evenOdd Q 0) (CliffordAlgebra.evenOdd Q 1)

full_name: CliffordAlgebra.evenOdd_induction
code: /-- To show a property is true on the even or odd part, it suffices to show it is true on the
scalars or vectors (respectively), closed under addition, and under left-multiplication by a pair
of vectors. -/
@[elab_as_elim]
theorem evenOdd_induction (n : ZMod 2) {motive : ∀ x, x ∈ evenOdd Q n → Prop}
    (range_ι_pow : ∀ (v) (h : v ∈ LinearMap.range (ι Q) ^ n.val),
        motive v (Submodule.mem_iSup_of_mem ⟨n.val, n.natCast_zmod_val⟩ h))
    (add : ∀ x y hx hy, motive x hx → motive y hy → motive (x + y) (Submodule.add_mem _ hx hy))
    (ι_mul_ι_mul :
      ∀ m₁ m₂ x hx,
        motive x hx →
          motive (ι Q m₁ * ι Q m₂ * x)
            (zero_add n ▸ SetLike.mul_mem_graded (ι_mul_ι_mem_evenOdd_zero Q m₁ m₂) hx))
    (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q n) : motive x hx 
goal: motive x hx

full_name: CliffordAlgebra.even_induction
code: /-- To show a property is true on the even parts, it suffices to show it is true on the
scalars, closed under addition, and under left-multiplication by a pair of vectors. -/
@[elab_as_elim]
theorem even_induction {motive : ∀ x, x ∈ evenOdd Q 0 → Prop}
    (algebraMap : ∀ r : R, motive (algebraMap _ _ r) (SetLike.algebraMap_mem_graded _ _))
    (add : ∀ x y hx hy, motive x hx → motive y hy → motive (x + y) (Submodule.add_mem _ hx hy))
    (ι_mul_ι_mul :
      ∀ m₁ m₂ x hx,
        motive x hx →
          motive (ι Q m₁ * ι Q m₂ * x)
            (zero_add (0 : ZMod 2) ▸ SetLike.mul_mem_graded (ι_mul_ι_mem_evenOdd_zero Q m₁ m₂) hx))
    (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 0) : motive x hx 
goal: motive x hx

full_name: CliffordAlgebra.odd_induction
code: /-- To show a property is true on the odd parts, it suffices to show it is true on the
vectors, closed under addition, and under left-multiplication by a pair of vectors. -/
@[elab_as_elim]
theorem odd_induction {P : ∀ x, x ∈ evenOdd Q 1 → Prop}
    (ι : ∀ v, P (ι Q v) (ι_mem_evenOdd_one _ _))
    (add : ∀ x y hx hy, P x hx → P y hy → P (x + y) (Submodule.add_mem _ hx hy))
    (ι_mul_ι_mul :
      ∀ m₁ m₂ x hx,
        P x hx →
          P (CliffordAlgebra.ι Q m₁ * CliffordAlgebra.ι Q m₂ * x)
            (zero_add (1 : ZMod 2) ▸ SetLike.mul_mem_graded (ι_mul_ι_mem_evenOdd_zero Q m₁ m₂) hx))
    (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 1) : P x hx 
goal: P x hx