Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

LeanProofs.Rosetta.SequentialCliffordMemory

Definition
Grade4_LeanProofs_Rosetta_SequentialCliffordMemory

by lisamegawatts · Sep 18, 2026 · Mathlib c5ea003 (Lean v4.30.0)

clifford-algebraleanproofs-grade4rosetta

Foundational definitions and structural lemmas from LeanProofs.Rosetta.SequentialCliffordMemory, required by the selected LeanProofs theorem graph.

Definition code
import Definitions.Def_Grade4_LeanProofs_Rosetta_Cl60BivectorGradeSupport
import Definitions.Def_Grade4_LeanProofs_Rosetta_ObstructionToDescent
import Definitions.Def_Grade4_LeanProofs_Foundations_Cl60BasisIndependence
import Mathlib.Tactic

namespace LeanProofsGrade4P2M


/-!
# Sequential Clifford memory

This module isolates an exact obstruction that first appears at arity three.
The registered `pairwiseFlat` observation is deliberately stronger than a
Killing/commutator/wedge summary: it retains **both ordered products** for all
three unordered pairs.  It is unchanged by simultaneous sign reversal, while
the ordered triple product changes sign.  A concrete Cl(6,0) witness has a
nonzero grade-six outcome.

The exact repair for the selected final-product readout is a running product.
This is an input-driven accumulator, not an autonomous law for the memory
coordinate alone.  An autonomous realization must also carry a source state
that supplies the next input.  The factorization results below establish only
fiber sufficiency/minimal separation for the registered outcome; they do not
establish minimum dimension, physical dynamics, causation, or a cross-scale
cascade.
-/

namespace Rosetta.SequentialCliffordMemory

open Rosetta.ObstructionToDescent

universe u v

/-! ## Representation-neutral arity-three obstruction -/

section GenericRing

variable {A : Type u} [Ring A]

/-- Three ordered inputs. -/
structure OrderedTriple (A : Type u) where
  first : A
  second : A
  third : A
deriving Repr

/-- The strongest binary ledger used here: both product orders. -/
def orderedPairProducts (a b : A) : A × A := (a * b, b * a)

/-- Every pair is retained, with both orders for each pair. -/
def pairwiseFlat (state : OrderedTriple A) :
    (A × A) × (A × A) × (A × A) :=
  (orderedPairProducts state.first state.second,
    orderedPairProducts state.first state.third,
    orderedPairProducts state.second state.third)

/-- Simultaneous orientation reversal of all three inputs. -/
def globalReverse (state : OrderedTriple A) : OrderedTriple A :=
  ⟨-state.first, -state.second, -state.third⟩

/-- The ordered arity-three interaction. -/
def tripleProduct (state : OrderedTriple A) : A :=
  state.first * state.second * state.third

@[simp] theorem pairwiseFlat_globalReverse (state : OrderedTriple A) :
    pairwiseFlat (globalReverse state) = pairwiseFlat state := by
  simp [pairwiseFlat, globalReverse, orderedPairProducts]

@[simp] theorem tripleProduct_globalReverse (state : OrderedTriple A) :
    tripleProduct (globalReverse state) = -tripleProduct state := by
  simp [tripleProduct, globalReverse]

/-- Complete binary data need not determine the ordered triple interaction. -/
def tripleProductDeterminationObstruction (state : OrderedTriple A)
    (hodd : tripleProduct state ≠ -tripleProduct state) :
    DeterminationObstruction (pairwiseFlat (A := A))
      (tripleProduct (A := A)) where
  left := state
  right := globalReverse state
  same_observation := (pairwiseFlat_globalReverse state).symm
  different_outcome := by
    rw [tripleProduct_globalReverse]
    exact hodd



/-! ## Running-product repair and its exact boundary -/

















/-! ## Autonomous realization requires an input source -/



variable {State : Type v}







end GenericRing

/-! ## Exact Cl(6,0) witnesses -/

open CliffordAlgebra

def E01 : Cl60 := e6Prod 0 1
def E23 : Cl60 := e6Prod 2 3
def E45 : Cl60 := e6Prod 4 5

def disjointPlaneTriple : OrderedTriple Cl60 := ⟨E01, E23, E45⟩

@[simp] theorem disjointPlaneTriple_product :
    tripleProduct disjointPlaneTriple = Cl60Even.pseudoscalar60 := by
  rfl

theorem pseudoscalar60_ne_neg :
    Cl60Even.pseudoscalar60 ≠ -Cl60Even.pseudoscalar60 := by
  intro h
  apply pseudoscalar60_ne_zero
  have htwo : (2 : ℝ) • Cl60Even.pseudoscalar60 = 0 := by
    calc
      (2 : ℝ) • Cl60Even.pseudoscalar60 =
          Cl60Even.pseudoscalar60 + Cl60Even.pseudoscalar60 := by
            rw [two_smul]
      _ = -Cl60Even.pseudoscalar60 + Cl60Even.pseudoscalar60 :=
        congrArg (fun value : Cl60 => value + Cl60Even.pseudoscalar60) h
      _ = 0 := neg_add_cancel _
  exact (smul_eq_zero.mp htwo).resolve_left (by norm_num)

/-- Concrete Cl(6,0) obstruction: even complete binary products do not recover
the signed disjoint-plane triple product. -/
def cl60TripleProductObstruction :
    DeterminationObstruction (pairwiseFlat (A := Cl60))
      (tripleProduct (A := Cl60)) :=
  tripleProductDeterminationObstruction disjointPlaneTriple (by
    simpa using pseudoscalar60_ne_neg)











end Rosetta.SequentialCliffordMemory


end LeanProofsGrade4P2M
Source
https://github.com/MonumentalSystems/LeanProofs/blob/b656238b73d5f0f74515f6574a1dcb4e0216129f/LeanProofs/Rosetta/SequentialCliffordMemory.lean

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me