Dataset Viewer
srcContext
stringlengths 274
35.4k
| theoremStatement
stringlengths 62
1.08k
| theoremName
stringlengths 16
52
| fileCreated
dict | theoremCreated
dict | file
stringlengths 26
42
| module
stringlengths 15
31
| jsonFile
stringlengths 21
37
| positionMetadata
dict | dependencyMetadata
dict | proofMetadata
dict |
---|---|---|---|---|---|---|---|---|---|---|
import ConNF.Model.RaiseStrong
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal
open scoped Pointwise
namespace ConNF
variable [Params.{u}]
/-- A redefinition of the derivative of allowable permutations that is invariant of level,
but still has nice definitional properties. -/
@[default_instance 200]
instance {β γ : TypeIndex} : Derivative (AllPerm β) (AllPerm γ) β γ where
deriv ρ A :=
A.recSderiv
(motive := λ (δ : TypeIndex) (A : β ↝ δ) ↦
letI : Level := ⟨δ.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel δ := ⟨δ.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show δ.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
AllPerm δ)
ρ (λ δ ε A h ρ ↦
letI : Level := ⟨δ.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel δ := ⟨δ.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show δ.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
letI : LeLevel ε := ⟨h.le.trans LeLevel.elim⟩
PreCoherentData.allPermSderiv h ρ)
@[simp]
theorem allPerm_deriv_nil' {β : TypeIndex}
(ρ : AllPerm β) :
ρ ⇘ (.nil : β ↝ β) = ρ :=
rfl
@[simp]
theorem allPerm_deriv_sderiv' {β γ δ : TypeIndex}
(ρ : AllPerm β) (A : β ↝ γ) (h : δ < γ) :
ρ ⇘ (A ↘ h) = ρ ⇘ A ↘ h :=
rfl
@[simp]
theorem allPermSderiv_forget' {β γ : TypeIndex} (h : γ < β) (ρ : AllPerm β) :
(ρ ↘ h)ᵁ = ρᵁ ↘ h :=
letI : Level := ⟨β.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel β := ⟨β.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show β.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
letI : LeLevel γ := ⟨h.le.trans LeLevel.elim⟩
allPermSderiv_forget h ρ
@[simp]
theorem allPerm_inv_sderiv' {β γ : TypeIndex} (h : γ < β) (ρ : AllPerm β) :
ρ⁻¹ ↘ h = (ρ ↘ h)⁻¹ := by
apply allPermForget_injective
rw [allPermSderiv_forget', allPermForget_inv, Tree.inv_sderiv, allPermForget_inv,
allPermSderiv_forget']
def Symmetric {α β : Λ} (s : Set (TSet β)) (hβ : (β : TypeIndex) < α) : Prop :=
∃ S : Support α, ∀ ρ : AllPerm α, ρᵁ • S = S → ρ ↘ hβ • s = s
def newSetEquiv {α : Λ} :
letI : Level := ⟨α⟩
@TSet _ α newModelData.toPreModelData ≃ TSet α :=
letI : Level := ⟨α⟩
castTSet (D₁ := newModelData) (D₂ := globalModelData) rfl
(by rw [globalModelData, motive_eq, constructMotive, globalLtData_eq])
@[simp]
theorem newSetEquiv_forget {α : Λ}
(x : letI : Level := ⟨α⟩; @TSet _ α newModelData.toPreModelData) :
(newSetEquiv x)ᵁ = xᵁ :=
letI : Level := ⟨α⟩
castTSet_forget (D₁ := newModelData) (D₂ := globalModelData) _ x
def allPermEquiv {α : Λ} :
letI : Level := ⟨α⟩
NewPerm ≃ AllPerm α :=
letI : Level := ⟨α⟩
castAllPerm (D₁ := newModelData) (D₂ := globalModelData) rfl
(by rw [globalModelData, motive_eq, constructMotive, globalLtData_eq])
@[simp]
theorem allPermEquiv_forget {α : Λ} (ρ : letI : Level := ⟨α⟩; NewPerm) :
(allPermEquiv ρ)ᵁ = ρᵁ :=
letI : Level := ⟨α⟩
castAllPerm_forget (D₁ := newModelData) (D₂ := globalModelData) _ ρ
theorem allPermEquiv_sderiv {α β : Λ}
(ρ : letI : Level := ⟨α⟩; NewPerm) (hβ : (β : TypeIndex) < α) :
letI : Level := ⟨α⟩
letI : LtLevel β := ⟨hβ⟩
allPermEquiv ρ ↘ hβ = ρ.sderiv β := by
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
letI : LtLevel β := ⟨hβ⟩
apply allPermForget_injective
rw [allPermSderiv_forget, allPermEquiv_forget, NewPerm.forget_sderiv]
theorem TSet.exists_of_symmetric {α β : Λ} (s : Set (TSet β)) (hβ : (β : TypeIndex) < α)
(hs : Symmetric s hβ) :
∃ x : TSet α, ∀ y : TSet β, y ∈[hβ] x ↔ y ∈ s := by
letI : Level := ⟨α⟩
letI : LtLevel β := ⟨hβ⟩
suffices ∃ x : (@TSet _ α newModelData.toPreModelData), ∀ y : TSet β, yᵁ ∈[hβ] xᵁ ↔ y ∈ s by
obtain ⟨x, hx⟩ := this
use newSetEquiv x
intro y
rw [← hx, ← TSet.forget_mem_forget, newSetEquiv_forget]
obtain rfl | hs' := s.eq_empty_or_nonempty
· use none
intro y
simp only [Set.mem_empty_iff_false, iff_false]
exact not_mem_none y
· use some (Code.toSet ⟨β, s, hs'⟩ ?_)
· intro y
erw [mem_some_iff]
exact Code.mem_toSet _
· obtain ⟨S, hS⟩ := hs
use S
intro ρ hρS
have := hS (allPermEquiv ρ) ?_
· simp only [NewPerm.smul_mk, Code.mk.injEq, heq_eq_eq, true_and]
rwa [allPermEquiv_sderiv] at this
· rwa [allPermEquiv_forget]
theorem TSet.exists_support {α : Λ} (x : TSet α) :
∃ S : Support α, ∀ ρ : AllPerm α, ρᵁ • S = S → ρ • x = x := by
letI : Level := ⟨α⟩
obtain ⟨S, hS⟩ := NewSet.exists_support (newSetEquiv.symm x)
use S
intro ρ hρ
have := @Support.Supports.supports _ _ _ newPreModelData _ _ _ hS (allPermEquiv.symm ρ) ?_
· apply tSetForget_injective
have := congr_arg (·ᵁ) this
simp only at this
erw [@smul_forget _ _ newModelData (allPermEquiv.symm ρ) (newSetEquiv.symm x),
← allPermEquiv_forget, ← newSetEquiv_forget, Equiv.apply_symm_apply,
Equiv.apply_symm_apply] at this
rwa [smul_forget]
· rwa [← allPermEquiv_forget, Equiv.apply_symm_apply]
| theorem TSet.symmetric {α β : Λ} (x : TSet α) (hβ : (β : TypeIndex) < α) :
Symmetric {y : TSet β | y ∈[hβ] x} hβ | ConNF.TSet.symmetric | {
"commit": "6fdc87c6b30b73931407a372f1430ecf0fef7601",
"date": "2024-12-03T00:00:00"
} | {
"commit": "b0bc9d69a413800c2ef0d0e3495ee0e71dc3fea7",
"date": "2024-12-01T00:00:00"
} | ConNF/ConNF/Model/TTT.lean | ConNF.Model.TTT | ConNF.Model.TTT.jsonl | {
"lineInFile": 154,
"tokenPositionInFile": 5178,
"theoremPositionInFile": 12
} | {
"inFilePremises": true,
"numInFilePremises": 4,
"repositoryPremises": true,
"numRepositoryPremises": 39,
"numPremises": 84
} | {
"hasProof": true,
"proof": ":= by\n obtain ⟨S, hS⟩ := exists_support x\n use S\n intro ρ hρ\n conv_rhs => rw [← hS ρ hρ]\n simp only [← forget_mem_forget, smul_forget, StrSet.mem_smul_iff]\n ext y\n rw [Set.mem_smul_set_iff_inv_smul_mem, Set.mem_setOf_eq, Set.mem_setOf_eq,\n smul_forget, allPermForget_inv, allPermSderiv_forget']",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 304
} |
import ConNF.Background.Rel
import ConNF.Base.Small
/-!
# Enumerations
In this file, we define enumerations of a type.
## Main declarations
* `ConNF.Enumeration`: The type family of enumerations.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}] {X Y : Type u}
@[ext]
structure Enumeration (X : Type u) where
bound : κ
rel : Rel κ X
lt_bound : ∀ i ∈ rel.dom, i < bound
rel_coinjective : rel.Coinjective
variable {E F G : Enumeration X}
namespace Enumeration
instance : CoeTC (Enumeration X) (Set X) where
coe E := E.rel.codom
instance : Membership X (Enumeration X) where
mem E x := x ∈ E.rel.codom
theorem mem_iff (x : X) (E : Enumeration X) :
x ∈ E ↔ x ∈ E.rel.codom :=
Iff.rfl
theorem mem_congr {E F : Enumeration X} (h : E = F) :
∀ x, x ∈ E ↔ x ∈ F := by
intro x
rw [h]
theorem dom_small (E : Enumeration X) :
Small E.rel.dom :=
(iio_small E.bound).mono E.lt_bound
theorem coe_small (E : Enumeration X) :
Small (E : Set X) :=
small_codom_of_small_dom E.rel_coinjective E.dom_small
theorem graph'_small (E : Enumeration X) :
Small E.rel.graph' :=
small_graph' E.dom_small E.coe_small
noncomputable def empty : Enumeration X where
bound := 0
rel _ _ := False
lt_bound _ h := by cases h; contradiction
rel_coinjective := by constructor; intros; contradiction
| @[simp]
theorem not_mem_empty (x : X) : x ∉ Enumeration.empty | ConNF.Enumeration.not_mem_empty | {
"commit": "39c33b4a743bea62dbcc549548b712ffd38ca65c",
"date": "2024-12-05T00:00:00"
} | {
"commit": "6709914ae7f5cd3e2bb24b413e09aa844554d234",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/ModelData/Enumeration.lean | ConNF.ModelData.Enumeration | ConNF.ModelData.Enumeration.jsonl | {
"lineInFile": 66,
"tokenPositionInFile": 1348,
"theoremPositionInFile": 5
} | {
"inFilePremises": true,
"numInFilePremises": 4,
"repositoryPremises": true,
"numRepositoryPremises": 6,
"numPremises": 13
} | {
"hasProof": true,
"proof": ":= by\n rintro ⟨i, h⟩\n cases h",
"proofType": "tactic",
"proofLengthLines": 2,
"proofLengthTokens": 31
} |
import ConNF.Levels.Path
/-!
# Trees
In this file, we define the notion of a tree on a type.
## Main declarations
* `ConNF.Tree`: The type family of trees parametrised by a given type.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}] {X Y : Type _} {α β γ : TypeIndex}
/-- An `α`-tree of `X` associates an object of type `X` to each path `α ↝ ⊥`. -/
def Tree (X : Type _) (α : TypeIndex) :=
(α ↝ ⊥) → X
namespace Tree
instance : Derivative (Tree X α) (Tree X β) α β where
deriv T A B := T (A ⇘ B)
@[simp]
theorem deriv_apply (T : Tree X α) (A : α ↝ β) (B : β ↝ ⊥) :
(T ⇘ A) B = T (A ⇘ B) :=
rfl
@[simp]
theorem deriv_nil (T : Tree X α) :
T ⇘ .nil = T := by
funext A
rw [deriv_apply, Path.nil_deriv]
theorem deriv_deriv (T : Tree X α) (A : α ↝ β) (B : β ↝ γ) :
T ⇘ A ⇘ B = T ⇘ (A ⇘ B) := by
funext C
simp only [deriv_apply, Path.deriv_assoc]
theorem deriv_sderiv (T : Tree X α) (A : α ↝ β) (h : γ < β) :
T ⇘ A ↘ h = T ⇘ (A ↘ h) := by
rw [← Derivative.deriv_single, ← Derivative.deriv_single, deriv_deriv]
@[simp]
theorem sderiv_apply (T : Tree X α) (h : β < α) (B : β ↝ ⊥) :
(T ↘ h) B = T (B ↗ h) :=
rfl
instance : BotDerivative (Tree X α) X α where
botDeriv T A := T A
botSderiv T := T <| Path.nil ↘.
botDeriv_single T h := by
cases α using WithBot.recBotCoe with
| bot => cases lt_irrefl ⊥ h
| coe => rfl
@[simp]
theorem botDeriv_eq (T : Tree X α) (A : α ↝ ⊥) :
T ⇘. A = T A :=
rfl
theorem botSderiv_eq (T : Tree X α) :
T ↘. = T (Path.nil ↘.) :=
rfl
/-- The group structure on the type of `α`-trees of `X` is given by "branchwise" multiplication,
given by `Pi.group`. -/
instance group [Group X] : Group (Tree X α) :=
Pi.group
@[simp]
theorem one_apply [Group X] (A : α ↝ ⊥) :
(1 : Tree X α) A = 1 :=
rfl
@[simp]
theorem one_deriv [Group X] (A : α ↝ β) :
(1 : Tree X α) ⇘ A = 1 :=
rfl
@[simp]
theorem one_sderiv [Group X] (h : β < α) :
(1 : Tree X α) ↘ h = 1 :=
rfl
@[simp]
theorem one_sderivBot [Group X] :
(1 : Tree X α) ↘. = 1 :=
rfl
@[simp]
theorem mul_apply [Group X] (T₁ T₂ : Tree X α) (A : α ↝ ⊥) :
(T₁ * T₂) A = T₁ A * T₂ A :=
rfl
| @[simp]
theorem mul_deriv [Group X] (T₁ T₂ : Tree X α) (A : α ↝ β) :
(T₁ * T₂) ⇘ A = T₁ ⇘ A * T₂ ⇘ A | ConNF.Tree.mul_deriv | {
"commit": "8896e416a16c39e1fe487b5fc7c78bc20c4e182b",
"date": "2024-12-03T00:00:00"
} | {
"commit": "012929981ca97cb4447881b386c61e3bac0c6b93",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/Levels/Tree.lean | ConNF.Levels.Tree | ConNF.Levels.Tree.jsonl | {
"lineInFile": 102,
"tokenPositionInFile": 2187,
"theoremPositionInFile": 13
} | {
"inFilePremises": true,
"numInFilePremises": 3,
"repositoryPremises": true,
"numRepositoryPremises": 7,
"numPremises": 16
} | {
"hasProof": true,
"proof": ":=\n rfl",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 8
} |
import ConNF.Model.Result
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal ConNF.TSet
namespace ConNF
variable [Params.{u}] {α β γ δ ε ζ : Λ} (hβ : (β : TypeIndex) < α) (hγ : (γ : TypeIndex) < β)
(hδ : (δ : TypeIndex) < γ) (hε : (ε : TypeIndex) < δ) (hζ : (ζ : TypeIndex) < ε)
def union (x y : TSet α) : TSet α :=
(xᶜ' ⊓' yᶜ')ᶜ'
notation:68 x:68 " ⊔[" h "] " y:68 => _root_.ConNF.union h x y
notation:68 x:68 " ⊔' " y:68 => x ⊔[by assumption] y
@[simp]
theorem mem_union_iff (x y : TSet α) :
∀ z : TSet β, z ∈' x ⊔' y ↔ z ∈' x ∨ z ∈' y := by
rw [union]
intro z
rw [mem_compl_iff, mem_inter_iff, mem_compl_iff, mem_compl_iff, or_iff_not_and_not]
def higherIndex (α : Λ) : Λ :=
(exists_gt α).choose
theorem lt_higherIndex {α : Λ} :
(α : TypeIndex) < higherIndex α :=
WithBot.coe_lt_coe.mpr (exists_gt α).choose_spec
theorem tSet_nonempty (h : ∃ β : Λ, (β : TypeIndex) < α) : Nonempty (TSet α) := by
obtain ⟨α', hα⟩ := h
constructor
apply typeLower lt_higherIndex lt_higherIndex lt_higherIndex hα
apply cardinalOne lt_higherIndex lt_higherIndex
def empty : TSet α :=
(tSet_nonempty ⟨β, hβ⟩).some ⊓' (tSet_nonempty ⟨β, hβ⟩).someᶜ'
@[simp]
theorem mem_empty_iff :
∀ x : TSet β, ¬x ∈' empty hβ := by
intro x
rw [empty, mem_inter_iff, mem_compl_iff]
exact and_not_self
def univ : TSet α :=
(empty hβ)ᶜ'
@[simp]
theorem mem_univ_iff :
∀ x : TSet β, x ∈' univ hβ := by
intro x
simp only [univ, mem_compl_iff, mem_empty_iff, not_false_eq_true]
/-- The set of all ordered pairs. -/
def orderedPairs : TSet α :=
vCross hβ hγ hδ (univ hδ)
@[simp]
theorem mem_orderedPairs_iff (x : TSet β) :
x ∈' orderedPairs hβ hγ hδ ↔ ∃ a b, x = ⟨a, b⟩' := by
simp only [orderedPairs, vCross_spec, mem_univ_iff, and_true]
def converse (x : TSet α) : TSet α :=
converse' hβ hγ hδ x ⊓' orderedPairs hβ hγ hδ
@[simp]
theorem op_mem_converse_iff (x : TSet α) :
∀ a b, ⟨a, b⟩' ∈' converse hβ hγ hδ x ↔ ⟨b, a⟩' ∈' x := by
intro a b
simp only [converse, mem_inter_iff, converse'_spec, mem_orderedPairs_iff, op_inj, exists_and_left,
exists_eq', and_true]
def cross (x y : TSet γ) : TSet α :=
converse hβ hγ hδ (vCross hβ hγ hδ x) ⊓' vCross hβ hγ hδ y
@[simp]
theorem mem_cross_iff (x y : TSet γ) :
∀ a, a ∈' cross hβ hγ hδ x y ↔ ∃ b c, a = ⟨b, c⟩' ∧ b ∈' x ∧ c ∈' y := by
intro a
rw [cross, mem_inter_iff, vCross_spec]
constructor
· rintro ⟨h₁, b, c, rfl, h₂⟩
simp only [op_mem_converse_iff, vCross_spec, op_inj] at h₁
obtain ⟨b', c', ⟨rfl, rfl⟩, h₁⟩ := h₁
exact ⟨b, c, rfl, h₁, h₂⟩
· rintro ⟨b, c, rfl, h₁, h₂⟩
simp only [op_mem_converse_iff, vCross_spec, op_inj]
exact ⟨⟨c, b, ⟨rfl, rfl⟩, h₁⟩, ⟨b, c, ⟨rfl, rfl⟩, h₂⟩⟩
def singletonImage (x : TSet β) : TSet α :=
singletonImage' hβ hγ hδ hε x ⊓' (cross hβ hγ hδ (cardinalOne hδ hε) (cardinalOne hδ hε))
@[simp]
theorem singletonImage_spec (x : TSet β) :
∀ z w,
⟨ {z}', {w}' ⟩' ∈' singletonImage hβ hγ hδ hε x ↔ ⟨z, w⟩' ∈' x := by
intro z w
rw [singletonImage, mem_inter_iff, singletonImage'_spec, and_iff_left_iff_imp]
intro hzw
rw [mem_cross_iff]
refine ⟨{z}', {w}', rfl, ?_⟩
simp only [mem_cardinalOne_iff, singleton_inj, exists_eq', and_self]
theorem exists_of_mem_singletonImage {x : TSet β} {z w : TSet δ}
(h : ⟨z, w⟩' ∈' singletonImage hβ hγ hδ hε x) :
∃ a b, z = {a}' ∧ w = {b}' := by
simp only [singletonImage, mem_inter_iff, mem_cross_iff, op_inj, mem_cardinalOne_iff] at h
obtain ⟨-, _, _, ⟨rfl, rfl⟩, ⟨a, rfl⟩, ⟨b, rfl⟩⟩ := h
exact ⟨a, b, rfl, rfl⟩
/-- Turn a model element encoding a relation into an actual relation. -/
def ExternalRel (r : TSet α) : Rel (TSet δ) (TSet δ) :=
λ x y ↦ ⟨x, y⟩' ∈' r
@[simp]
theorem externalRel_converse (r : TSet α) :
ExternalRel hβ hγ hδ (converse hβ hγ hδ r) = (ExternalRel hβ hγ hδ r).inv := by
ext
simp only [ExternalRel, op_mem_converse_iff, Rel.inv_apply]
/-- The codomain of a relation. -/
def codom (r : TSet α) : TSet γ :=
(typeLower lt_higherIndex hβ hγ hδ (singletonImage lt_higherIndex hβ hγ hδ r)ᶜ[lt_higherIndex])ᶜ'
| @[simp]
theorem mem_codom_iff (r : TSet α) (x : TSet δ) :
x ∈' codom hβ hγ hδ r ↔ x ∈ (ExternalRel hβ hγ hδ r).codom | ConNF.mem_codom_iff | {
"commit": "66f4e3291020d4198ca6ede816acae5cee584a07",
"date": "2025-01-06T00:00:00"
} | {
"commit": "66f4e3291020d4198ca6ede816acae5cee584a07",
"date": "2025-01-06T00:00:00"
} | ConNF/ConNF/External/Basic.lean | ConNF.External.Basic | ConNF.External.Basic.jsonl | {
"lineInFile": 139,
"tokenPositionInFile": 4169,
"theoremPositionInFile": 23
} | {
"inFilePremises": true,
"numInFilePremises": 7,
"repositoryPremises": true,
"numRepositoryPremises": 22,
"numPremises": 57
} | {
"hasProof": true,
"proof": ":= by\n simp only [codom, mem_compl_iff, mem_typeLower_iff, not_forall, not_not]\n constructor\n · rintro ⟨y, hy⟩\n obtain ⟨a, b, rfl, hb⟩ := exists_of_mem_singletonImage lt_higherIndex hβ hγ hδ hy\n rw [singleton_inj] at hb\n subst hb\n rw [singletonImage_spec] at hy\n exact ⟨a, hy⟩\n · rintro ⟨a, ha⟩\n use {a}'\n rw [singletonImage_spec]\n exact ha",
"proofType": "tactic",
"proofLengthLines": 12,
"proofLengthTokens": 368
} |
import ConNF.Model.Externalise
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal
namespace ConNF
variable [Params.{u}] {β γ : Λ} {hγ : (γ : TypeIndex) < β}
namespace Support
theorem not_mem_scoderiv_botDeriv (S : Support γ) (N : NearLitter) :
N ∉ (S ↗ hγ ⇘. (Path.nil ↘.))ᴺ := by
rintro ⟨i, ⟨A, N'⟩, h₁, h₂⟩
simp only [Prod.mk.injEq] at h₂
cases A
case sderiv δ A hδ _ =>
simp only [Path.deriv_sderiv] at h₂
cases A
case nil => cases h₂.1
case sderiv ζ A hζ _ =>
simp only [Path.deriv_sderiv] at h₂
cases h₂.1
variable [Level] [LtLevel β]
theorem not_mem_strong_botDeriv (S : Support γ) (N : NearLitter) :
N ∉ ((S ↗ hγ).strong ⇘. (Path.nil ↘.))ᴺ := by
rintro h
rw [strong, close_nearLitters, preStrong_nearLitters, Enumeration.mem_add_iff] at h
obtain h | h := h
· exact not_mem_scoderiv_botDeriv S N h
· rw [mem_constrainsNearLitters_nearLitters] at h
obtain ⟨B, N', hN', h⟩ := h
cases h using Relation.ReflTransGen.head_induction_on
case refl => exact not_mem_scoderiv_botDeriv S N hN'
case head x hx₁ hx₂ _ =>
obtain ⟨⟨γ, δ, ε, hδ, hε, hδε, A⟩, t, B, hB, hN, ht⟩ := hx₂
simp only at hB
cases B
case nil =>
cases hB
obtain ⟨C, N''⟩ := x
simp only at ht
cases ht.1
change _ ∈ t.supportᴺ at hN
rw [t.support_supports.2 rfl] at hN
obtain ⟨i, hN⟩ := hN
cases hN
case sderiv δ B hδ _ _ =>
cases B
case nil => cases hB
case sderiv ζ B hζ _ _ => cases hB
theorem raise_preStrong' (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hγ : (γ : TypeIndex) < β) :
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).PreStrong := by
apply hS.toPreStrong.add
constructor
intro A N hN P t hA ht
obtain ⟨A, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv hN
simp only [scoderiv_botDeriv_eq, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, interferenceSupport_nearLitters,
Enumeration.mem_add_iff, Enumeration.mem_smul, Enumeration.not_mem_empty, or_false] at hN
obtain ⟨δ, ε, ζ, hε, hζ, hεζ, B⟩ := P
dsimp only at *
cases A
case sderiv ζ' A hζ' _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_left_inj.mp at hA
cases A
case nil =>
cases hA
cases not_mem_strong_botDeriv T _ hN
case sderiv ι A hι _ _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
cases hA
haveI : LtLevel δ := ⟨A.le.trans_lt LtLevel.elim⟩
haveI : LtLevel ε := ⟨hε.trans LtLevel.elim⟩
haveI : LtLevel ζ := ⟨hζ.trans LtLevel.elim⟩
have := (T ↗ hγ).strong_strong.support_le hN ⟨δ, ε, ζ, hε, hζ, hεζ, A⟩
(ρ⁻¹ ⇘ A ↘ hε • t) rfl ?_
· simp only [Tangle.smul_support, allPermSderiv_forget, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv] at this
have := smul_le_smul this (ρᵁ ⇘ A ↘ hε)
simp only [smul_inv_smul] at this
apply le_trans this
intro B
constructor
· intro a ha
simp only [smul_derivBot, Tree.sderiv_apply, Tree.deriv_apply, Path.deriv_scoderiv,
deriv_derivBot, Enumeration.mem_smul] at ha
rw [deriv_derivBot, ← Path.deriv_scoderiv, Path.coderiv_deriv', scoderiv_botDeriv_eq,]
simp only [Path.deriv_scoderiv, add_derivBot, smul_derivBot,
BaseSupport.add_atoms, BaseSupport.smul_atoms, Enumeration.mem_add_iff,
Enumeration.mem_smul]
exact Or.inl ha
· intro N hN
simp only [smul_derivBot, Tree.sderiv_apply, Tree.deriv_apply, Path.deriv_scoderiv,
deriv_derivBot, Enumeration.mem_smul] at hN
rw [deriv_derivBot, ← Path.deriv_scoderiv, Path.coderiv_deriv', scoderiv_botDeriv_eq,]
simp only [Path.deriv_scoderiv, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, Enumeration.mem_add_iff,
Enumeration.mem_smul]
exact Or.inl hN
· rw [← smul_fuzz hε hζ hεζ, ← ht]
simp only [Path.botSderiv_coe_eq, BasePerm.smul_nearLitter_litter, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv, Tree.inv_sderivBot]
rfl
theorem raise_closed' (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hγ : (γ : TypeIndex) < β)
(hρ : ρᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim) :
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).Closed := by
constructor
intro A
constructor
intro N₁ N₂ hN₁ hN₂ a ha
simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff,
BaseSupport.add_atoms] at hN₁ hN₂ ⊢
obtain hN₁ | hN₁ := hN₁
· obtain hN₂ | hN₂ := hN₂
· exact Or.inl ((hS.closed A).interference_subset hN₁ hN₂ a ha)
· obtain ⟨B, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv hN₂
simp only [smul_add, scoderiv_botDeriv_eq, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, Enumeration.mem_add_iff,
Enumeration.mem_smul, BaseSupport.add_atoms, BaseSupport.smul_atoms] at hN₁ hN₂ ⊢
refine Or.inr (Or.inr ?_)
rw [mem_interferenceSupport_atoms]
refine ⟨(ρᵁ B)⁻¹ • N₁, ?_, (ρᵁ B)⁻¹ • N₂, ?_, ?_⟩
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
rw [← Enumeration.mem_smul, ← BaseSupport.smul_nearLitters, ← smul_derivBot, hρ]
exact Or.inl hN₁
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
simp only [interferenceSupport_nearLitters, Enumeration.not_mem_empty, or_false] at hN₂
exact Or.inr hN₂
· rw [← BasePerm.smul_interference]
exact Set.smul_mem_smul_set ha
· obtain ⟨B, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv hN₁
simp only [smul_add, scoderiv_botDeriv_eq, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, Enumeration.mem_add_iff,
Enumeration.mem_smul, BaseSupport.add_atoms, BaseSupport.smul_atoms] at hN₁ hN₂ ⊢
refine Or.inr (Or.inr ?_)
rw [mem_interferenceSupport_atoms]
refine ⟨(ρᵁ B)⁻¹ • N₁, ?_, (ρᵁ B)⁻¹ • N₂, ?_, ?_⟩
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
simp only [interferenceSupport_nearLitters, Enumeration.not_mem_empty, or_false] at hN₁
exact Or.inr hN₁
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
simp only [interferenceSupport_nearLitters, Enumeration.not_mem_empty, or_false] at hN₂
obtain hN₂ | hN₂ := hN₂
· rw [← Enumeration.mem_smul, ← BaseSupport.smul_nearLitters, ← smul_derivBot, hρ]
exact Or.inl hN₂
· exact Or.inr hN₂
· rw [← BasePerm.smul_interference]
exact Set.smul_mem_smul_set ha
theorem raise_strong' (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hγ : (γ : TypeIndex) < β)
(hρ : ρᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim) :
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).Strong :=
⟨raise_preStrong' S hS T ρ hγ, raise_closed' S hS T ρ hγ hρ⟩
| theorem convAtoms_injective_of_fixes {S : Support α} {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(A : ↑α ↝ ⊥) :
(convAtoms
(S + (ρ₁ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim) A).Injective | ConNF.Support.convAtoms_injective_of_fixes | {
"commit": "abf71bc79c407ceb462cc2edd2d994cda9cdef05",
"date": "2024-04-04T00:00:00"
} | {
"commit": "6709914ae7f5cd3e2bb24b413e09aa844554d234",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/Model/RaiseStrong.lean | ConNF.Model.RaiseStrong | ConNF.Model.RaiseStrong.jsonl | {
"lineInFile": 181,
"tokenPositionInFile": 7503,
"theoremPositionInFile": 5
} | {
"inFilePremises": false,
"numInFilePremises": 0,
"repositoryPremises": true,
"numRepositoryPremises": 71,
"numPremises": 148
} | {
"hasProof": true,
"proof": ":= by\n rw [Support.smul_eq_iff] at hρ₁ hρ₂\n constructor\n rintro a₁ a₂ a₃ ⟨i, hi₁, hi₂⟩ ⟨j, hj₁, hj₂⟩\n simp only [add_derivBot, BaseSupport.add_atoms, Rel.inv_apply,\n Enumeration.rel_add_iff] at hi₁ hi₂ hj₁ hj₂\n obtain hi₁ | ⟨i, rfl, hi₁⟩ := hi₁\n · obtain hi₂ | ⟨i', rfl, _⟩ := hi₂\n swap\n · have := Enumeration.lt_bound _ _ ⟨_, hi₁⟩\n simp only [add_lt_iff_neg_left] at this\n cases (κ_zero_le i').not_lt this\n cases (Enumeration.rel_coinjective _).coinjective hi₁ hi₂\n obtain hj₁ | ⟨j, rfl, hj₁⟩ := hj₁\n · obtain hj₂ | ⟨j', rfl, _⟩ := hj₂\n · exact (Enumeration.rel_coinjective _).coinjective hj₂ hj₁\n · have := Enumeration.lt_bound _ _ ⟨_, hj₁⟩\n simp only [add_lt_iff_neg_left] at this\n cases (κ_zero_le j').not_lt this\n · obtain hj₂ | hj₂ := hj₂\n · have := Enumeration.lt_bound _ _ ⟨_, hj₂⟩\n simp only [add_lt_iff_neg_left] at this\n cases (κ_zero_le j).not_lt this\n · simp only [add_right_inj, exists_eq_left] at hj₂\n obtain ⟨B, rfl⟩ := eq_of_atom_mem_scoderiv_botDeriv ⟨j, hj₁⟩\n simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_atoms,\n BaseSupport.add_atoms, Enumeration.smul_rel, add_right_inj, exists_eq_left] at hj₁ hj₂\n have := (Enumeration.rel_coinjective _).coinjective hj₁ hj₂\n rw [← (hρ₂ B).1 a₁ ⟨_, hi₁⟩, inv_smul_smul, inv_smul_eq_iff, (hρ₁ B).1 a₁ ⟨_, hi₁⟩] at this\n exact this.symm\n · obtain ⟨B, rfl⟩ := eq_of_atom_mem_scoderiv_botDeriv ⟨i, hi₁⟩\n simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_atoms,\n BaseSupport.add_atoms, Enumeration.smul_rel, add_right_inj, exists_eq_left] at hi₁ hi₂ hj₁ hj₂\n obtain hi₂ | hi₂ := hi₂\n · have := Enumeration.lt_bound _ _ ⟨_, hi₂⟩\n simp only [add_lt_iff_neg_left] at this\n cases (κ_zero_le i).not_lt this\n have hi := (Enumeration.rel_coinjective _).coinjective hi₁ hi₂\n suffices hj : (ρ₁ᵁ B)⁻¹ • a₂ = (ρ₂ᵁ B)⁻¹ • a₃ by\n rwa [← hj, smul_left_cancel_iff] at hi\n obtain hj₁ | ⟨j, rfl, hj₁⟩ := hj₁\n · obtain hj₂ | ⟨j', rfl, _⟩ := hj₂\n · rw [← (hρ₁ B).1 a₂ ⟨_, hj₁⟩, ← (hρ₂ B).1 a₃ ⟨_, hj₂⟩, inv_smul_smul, inv_smul_smul]\n exact (Enumeration.rel_coinjective _).coinjective hj₁ hj₂\n · have := Enumeration.lt_bound _ _ ⟨_, hj₁⟩\n simp only [add_lt_iff_neg_left] at this\n cases (κ_zero_le j').not_lt this\n · obtain hj₂ | hj₂ := hj₂\n · have := Enumeration.lt_bound _ _ ⟨_, hj₂⟩\n simp only [add_lt_iff_neg_left] at this\n cases (κ_zero_le j).not_lt this\n · simp only [add_right_inj, exists_eq_left] at hj₂\n exact (Enumeration.rel_coinjective _).coinjective hj₁ hj₂",
"proofType": "tactic",
"proofLengthLines": 52,
"proofLengthTokens": 2698
} |
import ConNF.ModelData.PathEnumeration
/-!
# Supports
In this file, we define the notion of a support.
## Main declarations
* `ConNF.BaseSupport`: The type of supports of atoms.
* `ConNF.Support`: The type of supports of objects of arbitrary type indices.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}]
/-!
## Base supports
-/
structure BaseSupport where
atoms : Enumeration Atom
nearLitters : Enumeration NearLitter
namespace BaseSupport
instance : SuperA BaseSupport (Enumeration Atom) where
superA := atoms
instance : SuperN BaseSupport (Enumeration NearLitter) where
superN := nearLitters
@[simp]
theorem mk_atoms {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴬ = a :=
rfl
@[simp]
theorem mk_nearLitters {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴺ = N :=
rfl
theorem atoms_congr {S T : BaseSupport} (h : S = T) :
Sᴬ = Tᴬ :=
h ▸ rfl
theorem nearLitters_congr {S T : BaseSupport} (h : S = T) :
Sᴺ = Tᴺ :=
h ▸ rfl
@[ext]
theorem ext {S T : BaseSupport} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
instance : SMul BasePerm BaseSupport where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms (π : BasePerm) (S : BaseSupport) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters (π : BasePerm) (S : BaseSupport) :
(π • S)ᴺ = π • Sᴺ :=
rfl
@[simp]
theorem smul_atoms_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
@[simp]
theorem smul_nearLitters_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance : MulAction BasePerm BaseSupport where
one_smul S := by
apply ext
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
theorem smul_eq_smul_iff (π₁ π₂ : BasePerm) (S : BaseSupport) :
π₁ • S = π₂ • S ↔ (∀ a ∈ Sᴬ, π₁ • a = π₂ • a) ∧ (∀ N ∈ Sᴺ, π₁ • N = π₂ • N) := by
constructor
· intro h
constructor
· rintro a ⟨i, ha⟩
have := congr_arg (·ᴬ.rel i (π₁ • a)) h
simp only [smul_atoms, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴬ.rel_coinjective.coinjective ha (this.mp ha)
rw [eq_inv_smul_iff] at this
rw [this]
· rintro N ⟨i, hN⟩
have := congr_arg (·ᴺ.rel i (π₁ • N)) h
simp only [smul_nearLitters, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴺ.rel_coinjective.coinjective hN (this.mp hN)
rw [eq_inv_smul_iff] at this
rw [this]
· intro h
ext : 2
· rfl
· ext i a : 3
rw [smul_atoms, smul_atoms, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
· rfl
· ext i a : 3
rw [smul_nearLitters, smul_nearLitters, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
theorem smul_eq_iff (π : BasePerm) (S : BaseSupport) :
π • S = S ↔ (∀ a ∈ Sᴬ, π • a = a) ∧ (∀ N ∈ Sᴺ, π • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul] at this
exact this
noncomputable instance : Add BaseSupport where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_atoms (S T : BaseSupport) :
(S + T)ᴬ = Sᴬ + Tᴬ :=
rfl
@[simp]
theorem add_nearLitters (S T : BaseSupport) :
(S + T)ᴺ = Sᴺ + Tᴺ :=
rfl
end BaseSupport
def baseSupportEquiv : BaseSupport ≃ Enumeration Atom × Enumeration NearLitter where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_baseSupport : #BaseSupport = #μ := by
rw [Cardinal.eq.mpr ⟨baseSupportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq card_atom, card_enumeration_eq card_nearLitter, mul_eq_self aleph0_lt_μ.le]
/-!
## Structural supports
-/
structure Support (α : TypeIndex) where
atoms : Enumeration (α ↝ ⊥ × Atom)
nearLitters : Enumeration (α ↝ ⊥ × NearLitter)
namespace Support
variable {α β : TypeIndex}
instance : SuperA (Support α) (Enumeration (α ↝ ⊥ × Atom)) where
superA := atoms
instance : SuperN (Support α) (Enumeration (α ↝ ⊥ × NearLitter)) where
superN := nearLitters
@[simp]
theorem mk_atoms (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴬ = E :=
rfl
@[simp]
theorem mk_nearLitters (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴺ = F :=
rfl
instance : Derivative (Support α) (Support β) α β where
deriv S A := ⟨Sᴬ ⇘ A, Sᴺ ⇘ A⟩
instance : Coderivative (Support β) (Support α) α β where
coderiv S A := ⟨Sᴬ ⇗ A, Sᴺ ⇗ A⟩
instance : BotDerivative (Support α) BaseSupport α where
botDeriv S A := ⟨Sᴬ ⇘. A, Sᴺ ⇘. A⟩
botSderiv S := ⟨Sᴬ ↘., Sᴺ ↘.⟩
botDeriv_single S h := by dsimp only; rw [botDeriv_single, botDeriv_single]
@[simp]
theorem deriv_atoms {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴬ ⇘ A = (S ⇘ A)ᴬ :=
rfl
@[simp]
theorem deriv_nearLitters {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴺ ⇘ A = (S ⇘ A)ᴺ :=
rfl
@[simp]
theorem sderiv_atoms {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴬ ↘ h = (S ↘ h)ᴬ :=
rfl
@[simp]
theorem sderiv_nearLitters {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴺ ↘ h = (S ↘ h)ᴺ :=
rfl
@[simp]
theorem coderiv_atoms {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴬ ⇗ A = (S ⇗ A)ᴬ :=
rfl
@[simp]
theorem coderiv_nearLitters {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴺ ⇗ A = (S ⇗ A)ᴺ :=
rfl
@[simp]
theorem scoderiv_atoms {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴬ ↗ h = (S ↗ h)ᴬ :=
rfl
@[simp]
theorem scoderiv_nearLitters {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴺ ↗ h = (S ↗ h)ᴺ :=
rfl
@[simp]
theorem derivBot_atoms {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴬ ⇘. A = (S ⇘. A)ᴬ :=
rfl
@[simp]
theorem derivBot_nearLitters {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴺ ⇘. A = (S ⇘. A)ᴺ :=
rfl
theorem ext' {S T : Support α} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
@[ext]
theorem ext {S T : Support α} (h : ∀ A, S ⇘. A = T ⇘. A) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
rw [mk.injEq]
constructor
· apply Enumeration.ext_path
intro A
exact BaseSupport.atoms_congr (h A)
· apply Enumeration.ext_path
intro A
exact BaseSupport.nearLitters_congr (h A)
@[simp]
theorem deriv_derivBot {α : TypeIndex} (S : Support α)
(A : α ↝ β) (B : β ↝ ⊥) :
S ⇘ A ⇘. B = S ⇘. (A ⇘ B) :=
rfl
@[simp]
theorem coderiv_deriv_eq {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
S ⇗ A ⇘ A = S :=
ext' (Sᴬ.coderiv_deriv_eq A) (Sᴺ.coderiv_deriv_eq A)
theorem eq_of_atom_mem_scoderiv_botDeriv {α β : TypeIndex} {S : Support β} {A : α ↝ ⊥}
{h : β < α} {a : Atom} (ha : a ∈ (S ↗ h ⇘. A)ᴬ) :
∃ B : β ↝ ⊥, A = B ↗ h :=
Enumeration.eq_of_mem_scoderiv_botDeriv ha
theorem eq_of_nearLitter_mem_scoderiv_botDeriv {α β : TypeIndex} {S : Support β} {A : α ↝ ⊥}
{h : β < α} {N : NearLitter} (hN : N ∈ (S ↗ h ⇘. A)ᴺ) :
∃ B : β ↝ ⊥, A = B ↗ h :=
Enumeration.eq_of_mem_scoderiv_botDeriv hN
@[simp]
theorem scoderiv_botDeriv_eq {α β : TypeIndex} (S : Support β) (A : β ↝ ⊥) (h : β < α) :
S ↗ h ⇘. (A ↗ h) = S ⇘. A :=
BaseSupport.ext (Enumeration.scoderiv_botDeriv_eq _ _ _) (Enumeration.scoderiv_botDeriv_eq _ _ _)
@[simp]
theorem scoderiv_deriv_eq {α β γ : TypeIndex} (S : Support β) (A : β ↝ γ) (h : β < α) :
S ↗ h ⇘ (A ↗ h) = S ⇘ A := by
apply ext
intro B
simp only [deriv_derivBot, ← scoderiv_botDeriv_eq S (A ⇘ B) h, Path.coderiv_deriv']
@[simp]
theorem coderiv_inj {α β : TypeIndex} (S T : Support β) (A : α ↝ β) :
S ⇗ A = T ⇗ A ↔ S = T := by
constructor
swap
· rintro rfl
rfl
intro h
ext B : 1
have : S ⇗ A ⇘ A ⇘. B = T ⇗ A ⇘ A ⇘. B := by rw [h]
rwa [coderiv_deriv_eq, coderiv_deriv_eq] at this
@[simp]
theorem scoderiv_inj {α β : TypeIndex} (S T : Support β) (h : β < α) :
S ↗ h = T ↗ h ↔ S = T :=
coderiv_inj S T (.single h)
instance {α : TypeIndex} : SMul (StrPerm α) (Support α) where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms {α : TypeIndex} (π : StrPerm α) (S : Support α) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters {α : TypeIndex} (π : StrPerm α) (S : Support α) :
(π • S)ᴺ = π • Sᴺ :=
rfl
theorem smul_atoms_eq_of_smul_eq {α : TypeIndex} {π : StrPerm α} {S : Support α}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
theorem smul_nearLitters_eq_of_smul_eq {α : TypeIndex} {π : StrPerm α} {S : Support α}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance {α : TypeIndex} : MulAction (StrPerm α) (Support α) where
one_smul S := by
apply ext'
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext'
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
@[simp]
theorem smul_derivBot {α : TypeIndex} (π : StrPerm α) (S : Support α) (A : α ↝ ⊥) :
(π • S) ⇘. A = π A • (S ⇘. A) :=
rfl
theorem smul_coderiv {α : TypeIndex} (π : StrPerm α) (S : Support β) (A : α ↝ β) :
π • S ⇗ A = (π ⇘ A • S) ⇗ A := by
ext B i x
· rfl
· constructor
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, x⟩, hS, rfl⟩
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, _⟩, hS, rfl⟩
· rfl
· constructor
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, x⟩, hS, rfl⟩
· rintro ⟨⟨C, a⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, _⟩, hS, rfl⟩
theorem smul_scoderiv {α : TypeIndex} (π : StrPerm α) (S : Support β) (h : β < α) :
π • S ↗ h = (π ↘ h • S) ↗ h :=
smul_coderiv π S (Path.single h)
theorem smul_eq_smul_iff (π₁ π₂ : StrPerm β) (S : Support β) :
π₁ • S = π₂ • S ↔
∀ A, (∀ a ∈ (S ⇘. A)ᴬ, π₁ A • a = π₂ A • a) ∧ (∀ N ∈ (S ⇘. A)ᴺ, π₁ A • N = π₂ A • N) := by
constructor
· intro h A
have := congr_arg (· ⇘. A) h
simp only [smul_derivBot, BaseSupport.smul_eq_smul_iff] at this
exact this
· intro h
apply ext
intro A
simp only [smul_derivBot, BaseSupport.smul_eq_smul_iff]
exact h A
theorem smul_eq_iff (π : StrPerm β) (S : Support β) :
π • S = S ↔ ∀ A, (∀ a ∈ (S ⇘. A)ᴬ, π A • a = a) ∧ (∀ N ∈ (S ⇘. A)ᴺ, π A • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul, Tree.one_apply] at this
exact this
noncomputable instance : Add (Support α) where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_derivBot (S T : Support α) (A : α ↝ ⊥) :
(S + T) ⇘. A = (S ⇘. A) + (T ⇘. A) :=
rfl
theorem smul_add (S T : Support α) (π : StrPerm α) :
π • (S + T) = π • S + π • T :=
rfl
theorem add_inj_of_bound_eq_bound {S T U V : Support α}
(ha : Sᴬ.bound = Tᴬ.bound) (hN : Sᴺ.bound = Tᴺ.bound)
(h' : S + U = T + V) : S = T ∧ U = V := by
have ha' := Enumeration.add_inj_of_bound_eq_bound ha (congr_arg (·ᴬ) h')
have hN' := Enumeration.add_inj_of_bound_eq_bound hN (congr_arg (·ᴺ) h')
constructor
· exact Support.ext' ha'.1 hN'.1
· exact Support.ext' ha'.2 hN'.2
end Support
def supportEquiv {α : TypeIndex} : Support α ≃
Enumeration (α ↝ ⊥ × Atom) × Enumeration (α ↝ ⊥ × NearLitter) where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_support {α : TypeIndex} : #(Support α) = #μ := by
rw [Cardinal.eq.mpr ⟨supportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq, card_enumeration_eq, mul_eq_self aleph0_lt_μ.le]
· rw [mk_prod, lift_id, lift_id, card_nearLitter,
mul_eq_right aleph0_lt_μ.le (card_path_lt' α ⊥).le (card_path_ne_zero α)]
· rw [mk_prod, lift_id, lift_id, card_atom,
mul_eq_right aleph0_lt_μ.le (card_path_lt' α ⊥).le (card_path_ne_zero α)]
/-!
## Orders on supports
-/
-- TODO: Is this order used?
instance : LE BaseSupport where
le S T := (∀ a ∈ Sᴬ, a ∈ Tᴬ) ∧ (∀ N ∈ Sᴺ, N ∈ Tᴺ)
instance : Preorder BaseSupport where
le_refl S := ⟨λ _ ↦ id, λ _ ↦ id⟩
le_trans S T U h₁ h₂ := ⟨λ a h ↦ h₂.1 _ (h₁.1 a h), λ N h ↦ h₂.2 _ (h₁.2 N h)⟩
theorem BaseSupport.smul_le_smul {S T : BaseSupport} (h : S ≤ T) (π : BasePerm) :
π • S ≤ π • T := by
constructor
· intro a
exact h.1 (π⁻¹ • a)
· intro N
exact h.2 (π⁻¹ • N)
theorem BaseSupport.le_add_right {S T : BaseSupport} :
S ≤ S + T := by
constructor
· intro a ha
simp only [Support.add_derivBot, BaseSupport.add_atoms, Enumeration.mem_add_iff]
exact Or.inl ha
· intro N hN
simp only [Support.add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
exact Or.inl hN
| theorem BaseSupport.le_add_left {S T : BaseSupport} :
S ≤ T + S | ConNF.BaseSupport.le_add_left | {
"commit": "39c33b4a743bea62dbcc549548b712ffd38ca65c",
"date": "2024-12-05T00:00:00"
} | {
"commit": "251ac752f844dfde539ac2bd3ff112305ad59139",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/ModelData/Support.lean | ConNF.ModelData.Support | ConNF.ModelData.Support.jsonl | {
"lineInFile": 487,
"tokenPositionInFile": 13576,
"theoremPositionInFile": 51
} | {
"inFilePremises": true,
"numInFilePremises": 5,
"repositoryPremises": true,
"numRepositoryPremises": 14,
"numPremises": 25
} | {
"hasProof": true,
"proof": ":= by\n constructor\n · intro a ha\n simp only [add_atoms, Enumeration.mem_add_iff]\n exact Or.inr ha\n · intro N hN\n simp only [add_nearLitters, Enumeration.mem_add_iff]\n exact Or.inr hN",
"proofType": "tactic",
"proofLengthLines": 7,
"proofLengthTokens": 197
} |
import ConNF.ModelData.PathEnumeration
/-!
# Supports
In this file, we define the notion of a support.
## Main declarations
* `ConNF.BaseSupport`: The type of supports of atoms.
* `ConNF.Support`: The type of supports of objects of arbitrary type indices.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}]
/-!
## Base supports
-/
structure BaseSupport where
atoms : Enumeration Atom
nearLitters : Enumeration NearLitter
namespace BaseSupport
instance : SuperA BaseSupport (Enumeration Atom) where
superA := atoms
instance : SuperN BaseSupport (Enumeration NearLitter) where
superN := nearLitters
@[simp]
theorem mk_atoms {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴬ = a :=
rfl
@[simp]
theorem mk_nearLitters {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴺ = N :=
rfl
theorem atoms_congr {S T : BaseSupport} (h : S = T) :
Sᴬ = Tᴬ :=
h ▸ rfl
theorem nearLitters_congr {S T : BaseSupport} (h : S = T) :
Sᴺ = Tᴺ :=
h ▸ rfl
@[ext]
theorem ext {S T : BaseSupport} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
instance : SMul BasePerm BaseSupport where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms (π : BasePerm) (S : BaseSupport) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters (π : BasePerm) (S : BaseSupport) :
(π • S)ᴺ = π • Sᴺ :=
rfl
@[simp]
theorem smul_atoms_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
@[simp]
theorem smul_nearLitters_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance : MulAction BasePerm BaseSupport where
one_smul S := by
apply ext
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
theorem smul_eq_smul_iff (π₁ π₂ : BasePerm) (S : BaseSupport) :
π₁ • S = π₂ • S ↔ (∀ a ∈ Sᴬ, π₁ • a = π₂ • a) ∧ (∀ N ∈ Sᴺ, π₁ • N = π₂ • N) := by
constructor
· intro h
constructor
· rintro a ⟨i, ha⟩
have := congr_arg (·ᴬ.rel i (π₁ • a)) h
simp only [smul_atoms, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴬ.rel_coinjective.coinjective ha (this.mp ha)
rw [eq_inv_smul_iff] at this
rw [this]
· rintro N ⟨i, hN⟩
have := congr_arg (·ᴺ.rel i (π₁ • N)) h
simp only [smul_nearLitters, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴺ.rel_coinjective.coinjective hN (this.mp hN)
rw [eq_inv_smul_iff] at this
rw [this]
· intro h
ext : 2
· rfl
· ext i a : 3
rw [smul_atoms, smul_atoms, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
· rfl
· ext i a : 3
rw [smul_nearLitters, smul_nearLitters, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
theorem smul_eq_iff (π : BasePerm) (S : BaseSupport) :
π • S = S ↔ (∀ a ∈ Sᴬ, π • a = a) ∧ (∀ N ∈ Sᴺ, π • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul] at this
exact this
noncomputable instance : Add BaseSupport where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_atoms (S T : BaseSupport) :
(S + T)ᴬ = Sᴬ + Tᴬ :=
rfl
@[simp]
theorem add_nearLitters (S T : BaseSupport) :
(S + T)ᴺ = Sᴺ + Tᴺ :=
rfl
end BaseSupport
def baseSupportEquiv : BaseSupport ≃ Enumeration Atom × Enumeration NearLitter where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_baseSupport : #BaseSupport = #μ := by
rw [Cardinal.eq.mpr ⟨baseSupportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq card_atom, card_enumeration_eq card_nearLitter, mul_eq_self aleph0_lt_μ.le]
/-!
## Structural supports
-/
structure Support (α : TypeIndex) where
atoms : Enumeration (α ↝ ⊥ × Atom)
nearLitters : Enumeration (α ↝ ⊥ × NearLitter)
namespace Support
variable {α β : TypeIndex}
instance : SuperA (Support α) (Enumeration (α ↝ ⊥ × Atom)) where
superA := atoms
instance : SuperN (Support α) (Enumeration (α ↝ ⊥ × NearLitter)) where
superN := nearLitters
@[simp]
theorem mk_atoms (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴬ = E :=
rfl
@[simp]
theorem mk_nearLitters (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴺ = F :=
rfl
instance : Derivative (Support α) (Support β) α β where
deriv S A := ⟨Sᴬ ⇘ A, Sᴺ ⇘ A⟩
instance : Coderivative (Support β) (Support α) α β where
coderiv S A := ⟨Sᴬ ⇗ A, Sᴺ ⇗ A⟩
instance : BotDerivative (Support α) BaseSupport α where
botDeriv S A := ⟨Sᴬ ⇘. A, Sᴺ ⇘. A⟩
botSderiv S := ⟨Sᴬ ↘., Sᴺ ↘.⟩
botDeriv_single S h := by dsimp only; rw [botDeriv_single, botDeriv_single]
@[simp]
theorem deriv_atoms {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴬ ⇘ A = (S ⇘ A)ᴬ :=
rfl
@[simp]
theorem deriv_nearLitters {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴺ ⇘ A = (S ⇘ A)ᴺ :=
rfl
@[simp]
theorem sderiv_atoms {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴬ ↘ h = (S ↘ h)ᴬ :=
rfl
@[simp]
theorem sderiv_nearLitters {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴺ ↘ h = (S ↘ h)ᴺ :=
rfl
@[simp]
theorem coderiv_atoms {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴬ ⇗ A = (S ⇗ A)ᴬ :=
rfl
@[simp]
theorem coderiv_nearLitters {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴺ ⇗ A = (S ⇗ A)ᴺ :=
rfl
@[simp]
theorem scoderiv_atoms {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴬ ↗ h = (S ↗ h)ᴬ :=
rfl
@[simp]
theorem scoderiv_nearLitters {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴺ ↗ h = (S ↗ h)ᴺ :=
rfl
@[simp]
theorem derivBot_atoms {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴬ ⇘. A = (S ⇘. A)ᴬ :=
rfl
@[simp]
theorem derivBot_nearLitters {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴺ ⇘. A = (S ⇘. A)ᴺ :=
rfl
theorem ext' {S T : Support α} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
@[ext]
theorem ext {S T : Support α} (h : ∀ A, S ⇘. A = T ⇘. A) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
rw [mk.injEq]
constructor
· apply Enumeration.ext_path
intro A
exact BaseSupport.atoms_congr (h A)
· apply Enumeration.ext_path
intro A
exact BaseSupport.nearLitters_congr (h A)
@[simp]
theorem deriv_derivBot {α : TypeIndex} (S : Support α)
(A : α ↝ β) (B : β ↝ ⊥) :
S ⇘ A ⇘. B = S ⇘. (A ⇘ B) :=
rfl
@[simp]
theorem coderiv_deriv_eq {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
S ⇗ A ⇘ A = S :=
ext' (Sᴬ.coderiv_deriv_eq A) (Sᴺ.coderiv_deriv_eq A)
theorem eq_of_atom_mem_scoderiv_botDeriv {α β : TypeIndex} {S : Support β} {A : α ↝ ⊥}
{h : β < α} {a : Atom} (ha : a ∈ (S ↗ h ⇘. A)ᴬ) :
∃ B : β ↝ ⊥, A = B ↗ h :=
Enumeration.eq_of_mem_scoderiv_botDeriv ha
theorem eq_of_nearLitter_mem_scoderiv_botDeriv {α β : TypeIndex} {S : Support β} {A : α ↝ ⊥}
{h : β < α} {N : NearLitter} (hN : N ∈ (S ↗ h ⇘. A)ᴺ) :
∃ B : β ↝ ⊥, A = B ↗ h :=
Enumeration.eq_of_mem_scoderiv_botDeriv hN
@[simp]
theorem scoderiv_botDeriv_eq {α β : TypeIndex} (S : Support β) (A : β ↝ ⊥) (h : β < α) :
S ↗ h ⇘. (A ↗ h) = S ⇘. A :=
BaseSupport.ext (Enumeration.scoderiv_botDeriv_eq _ _ _) (Enumeration.scoderiv_botDeriv_eq _ _ _)
@[simp]
theorem scoderiv_deriv_eq {α β γ : TypeIndex} (S : Support β) (A : β ↝ γ) (h : β < α) :
S ↗ h ⇘ (A ↗ h) = S ⇘ A := by
apply ext
intro B
simp only [deriv_derivBot, ← scoderiv_botDeriv_eq S (A ⇘ B) h, Path.coderiv_deriv']
@[simp]
theorem coderiv_inj {α β : TypeIndex} (S T : Support β) (A : α ↝ β) :
S ⇗ A = T ⇗ A ↔ S = T := by
constructor
swap
· rintro rfl
rfl
intro h
ext B : 1
have : S ⇗ A ⇘ A ⇘. B = T ⇗ A ⇘ A ⇘. B := by rw [h]
rwa [coderiv_deriv_eq, coderiv_deriv_eq] at this
@[simp]
theorem scoderiv_inj {α β : TypeIndex} (S T : Support β) (h : β < α) :
S ↗ h = T ↗ h ↔ S = T :=
coderiv_inj S T (.single h)
instance {α : TypeIndex} : SMul (StrPerm α) (Support α) where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms {α : TypeIndex} (π : StrPerm α) (S : Support α) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters {α : TypeIndex} (π : StrPerm α) (S : Support α) :
(π • S)ᴺ = π • Sᴺ :=
rfl
theorem smul_atoms_eq_of_smul_eq {α : TypeIndex} {π : StrPerm α} {S : Support α}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
theorem smul_nearLitters_eq_of_smul_eq {α : TypeIndex} {π : StrPerm α} {S : Support α}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance {α : TypeIndex} : MulAction (StrPerm α) (Support α) where
one_smul S := by
apply ext'
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext'
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
@[simp]
theorem smul_derivBot {α : TypeIndex} (π : StrPerm α) (S : Support α) (A : α ↝ ⊥) :
(π • S) ⇘. A = π A • (S ⇘. A) :=
rfl
theorem smul_coderiv {α : TypeIndex} (π : StrPerm α) (S : Support β) (A : α ↝ β) :
π • S ⇗ A = (π ⇘ A • S) ⇗ A := by
ext B i x
· rfl
· constructor
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, x⟩, hS, rfl⟩
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, _⟩, hS, rfl⟩
· rfl
· constructor
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, x⟩, hS, rfl⟩
· rintro ⟨⟨C, a⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, _⟩, hS, rfl⟩
theorem smul_scoderiv {α : TypeIndex} (π : StrPerm α) (S : Support β) (h : β < α) :
π • S ↗ h = (π ↘ h • S) ↗ h :=
smul_coderiv π S (Path.single h)
theorem smul_eq_smul_iff (π₁ π₂ : StrPerm β) (S : Support β) :
π₁ • S = π₂ • S ↔
∀ A, (∀ a ∈ (S ⇘. A)ᴬ, π₁ A • a = π₂ A • a) ∧ (∀ N ∈ (S ⇘. A)ᴺ, π₁ A • N = π₂ A • N) := by
constructor
· intro h A
have := congr_arg (· ⇘. A) h
simp only [smul_derivBot, BaseSupport.smul_eq_smul_iff] at this
exact this
· intro h
apply ext
intro A
simp only [smul_derivBot, BaseSupport.smul_eq_smul_iff]
exact h A
theorem smul_eq_iff (π : StrPerm β) (S : Support β) :
π • S = S ↔ ∀ A, (∀ a ∈ (S ⇘. A)ᴬ, π A • a = a) ∧ (∀ N ∈ (S ⇘. A)ᴺ, π A • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul, Tree.one_apply] at this
exact this
noncomputable instance : Add (Support α) where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_derivBot (S T : Support α) (A : α ↝ ⊥) :
(S + T) ⇘. A = (S ⇘. A) + (T ⇘. A) :=
rfl
theorem smul_add (S T : Support α) (π : StrPerm α) :
π • (S + T) = π • S + π • T :=
rfl
theorem add_inj_of_bound_eq_bound {S T U V : Support α}
(ha : Sᴬ.bound = Tᴬ.bound) (hN : Sᴺ.bound = Tᴺ.bound)
(h' : S + U = T + V) : S = T ∧ U = V := by
have ha' := Enumeration.add_inj_of_bound_eq_bound ha (congr_arg (·ᴬ) h')
have hN' := Enumeration.add_inj_of_bound_eq_bound hN (congr_arg (·ᴺ) h')
constructor
· exact Support.ext' ha'.1 hN'.1
· exact Support.ext' ha'.2 hN'.2
end Support
def supportEquiv {α : TypeIndex} : Support α ≃
Enumeration (α ↝ ⊥ × Atom) × Enumeration (α ↝ ⊥ × NearLitter) where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_support {α : TypeIndex} : #(Support α) = #μ := by
rw [Cardinal.eq.mpr ⟨supportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq, card_enumeration_eq, mul_eq_self aleph0_lt_μ.le]
· rw [mk_prod, lift_id, lift_id, card_nearLitter,
mul_eq_right aleph0_lt_μ.le (card_path_lt' α ⊥).le (card_path_ne_zero α)]
· rw [mk_prod, lift_id, lift_id, card_atom,
mul_eq_right aleph0_lt_μ.le (card_path_lt' α ⊥).le (card_path_ne_zero α)]
/-!
## Orders on supports
-/
-- TODO: Is this order used?
instance : LE BaseSupport where
le S T := (∀ a ∈ Sᴬ, a ∈ Tᴬ) ∧ (∀ N ∈ Sᴺ, N ∈ Tᴺ)
instance : Preorder BaseSupport where
le_refl S := ⟨λ _ ↦ id, λ _ ↦ id⟩
le_trans S T U h₁ h₂ := ⟨λ a h ↦ h₂.1 _ (h₁.1 a h), λ N h ↦ h₂.2 _ (h₁.2 N h)⟩
theorem BaseSupport.smul_le_smul {S T : BaseSupport} (h : S ≤ T) (π : BasePerm) :
π • S ≤ π • T := by
constructor
· intro a
exact h.1 (π⁻¹ • a)
· intro N
exact h.2 (π⁻¹ • N)
| theorem BaseSupport.le_add_right {S T : BaseSupport} :
S ≤ S + T | ConNF.BaseSupport.le_add_right | {
"commit": "39c33b4a743bea62dbcc549548b712ffd38ca65c",
"date": "2024-12-05T00:00:00"
} | {
"commit": "251ac752f844dfde539ac2bd3ff112305ad59139",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/ModelData/Support.lean | ConNF.ModelData.Support | ConNF.ModelData.Support.jsonl | {
"lineInFile": 477,
"tokenPositionInFile": 13240,
"theoremPositionInFile": 50
} | {
"inFilePremises": true,
"numInFilePremises": 5,
"repositoryPremises": true,
"numRepositoryPremises": 14,
"numPremises": 25
} | {
"hasProof": true,
"proof": ":= by\n constructor\n · intro a ha\n simp only [Support.add_derivBot, BaseSupport.add_atoms, Enumeration.mem_add_iff]\n exact Or.inl ha\n · intro N hN\n simp only [Support.add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]\n exact Or.inl hN",
"proofType": "tactic",
"proofLengthLines": 7,
"proofLengthTokens": 265
} |
import ConNF.External.Basic
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal ConNF.TSet
namespace ConNF
variable [Params.{u}] {α β γ δ ε ζ : Λ} (hβ : (β : TypeIndex) < α) (hγ : (γ : TypeIndex) < β)
(hδ : (δ : TypeIndex) < γ) (hε : (ε : TypeIndex) < δ) (hζ : (ζ : TypeIndex) < ε)
/-- A set in our model that is a well-order. Internal well-orders are exactly external well-orders,
so we externalise the definition for convenience. -/
def InternalWellOrder (r : TSet α) : Prop :=
IsWellOrder (ExternalRel hβ hγ hδ r).field
(InvImage (ExternalRel hβ hγ hδ r) Subtype.val)
def InternallyWellOrdered (x : TSet γ) : Prop :=
{y : TSet δ | y ∈' x}.Subsingleton ∨ (∃ r, InternalWellOrder hβ hγ hδ r ∧ x = field hβ hγ hδ r)
@[simp]
theorem externalRel_smul (r : TSet α) (ρ : AllPerm α) :
ExternalRel hβ hγ hδ (ρ • r) =
InvImage (ExternalRel hβ hγ hδ r) ((ρ ↘ hβ ↘ hγ ↘ hδ)⁻¹ • ·) := by
ext a b
simp only [ExternalRel, mem_smul_iff', allPerm_inv_sderiv', smul_op, InvImage]
omit [Params] in
/-- Well-orders are rigid. -/
theorem apply_eq_of_isWellOrder {X : Type _} {r : Rel X X} {f : X → X}
(hr : IsWellOrder X r) (hf : Function.Bijective f) (hf' : ∀ x y, r x y ↔ r (f x) (f y)) :
∀ x, f x = x := by
let emb : r ≼i r := ⟨⟨⟨f, hf.injective⟩, λ {a b} ↦ (hf' a b).symm⟩, ?_⟩
· have : emb = InitialSeg.refl r := Subsingleton.elim _ _
intro x
exact congr_arg (λ f ↦ f x) this
· intro a b h
exact hf.surjective _
omit [Params] in
theorem apply_eq_of_isWellOrder' {X : Type _} {r : Rel X X} {f : X → X}
(hr : IsWellOrder r.field (InvImage r Subtype.val)) (hf : Function.Bijective f)
(hf' : ∀ x y, r x y ↔ r (f x) (f y)) :
∀ x ∈ r.field, f x = x := by
have : ∀ x ∈ r.field, f x ∈ r.field := by
rintro x (⟨y, h⟩ | ⟨y, h⟩)
· exact Or.inl ⟨f y, (hf' x y).mp h⟩
· exact Or.inr ⟨f y, (hf' y x).mp h⟩
have := apply_eq_of_isWellOrder (f := λ x ↦ ⟨f x.val, this x.val x.prop⟩) hr ⟨?_, ?_⟩ ?_
· intro x hx
exact congr_arg Subtype.val (this ⟨x, hx⟩)
· intro x y h
rw [Subtype.mk.injEq] at h
exact Subtype.val_injective (hf.injective h)
· intro x
obtain ⟨y, hy⟩ := hf.surjective x.val
refine ⟨⟨y, ?_⟩, ?_⟩
· obtain (⟨z, h⟩ | ⟨z, h⟩) := x.prop <;>
rw [← hy] at h <;>
obtain ⟨z, rfl⟩ := hf.surjective z
· exact Or.inl ⟨z, (hf' y z).mpr h⟩
· exact Or.inr ⟨z, (hf' z y).mpr h⟩
· simp only [hy]
· intros
apply hf'
theorem exists_common_support_of_internallyWellOrdered' {x : TSet δ}
(h : InternallyWellOrdered hγ hδ hε x) :
∃ S : Support β, ∀ y, y ∈' x → S.Supports { { {y}' }' }[hγ] := by
obtain (h | ⟨r, h, rfl⟩) := h
· obtain (h | ⟨y, hy⟩) := h.eq_empty_or_singleton
· use ⟨Enumeration.empty, Enumeration.empty⟩
intro y hy
rw [Set.eq_empty_iff_forall_not_mem] at h
cases h y hy
· obtain ⟨S, hS⟩ := TSet.exists_support y
use S ↗ hε ↗ hδ ↗ hγ
intro z hz
rw [Set.eq_singleton_iff_unique_mem] at hy
cases hy.2 z hz
refine ⟨?_, λ h ↦ by cases h⟩
intro ρ hρ
simp only [Support.smul_scoderiv, ← allPermSderiv_forget', Support.scoderiv_inj] at hρ
simp only [smul_singleton, singleton_inj]
exact hS _ hρ
obtain ⟨S, hS⟩ := TSet.exists_support r
use S
intro a ha
refine ⟨?_, λ h ↦ by cases h⟩
intro ρ hρ
have := hS ρ hρ
simp only [smul_singleton, singleton_inj]
apply apply_eq_of_isWellOrder' (r := ExternalRel hγ hδ hε r)
· exact h
· exact MulAction.bijective (ρ ↘ hγ ↘ hδ ↘ hε)
· intro x y
conv_rhs => rw [← this]
simp only [externalRel_smul, InvImage, inv_smul_smul]
· rwa [mem_field_iff] at ha
include hγ in
| theorem Support.Supports.ofSingleton {S : Support α} {x : TSet β}
(h : S.Supports {x}') :
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
(S.strong ↘ hβ).Supports x | ConNF.Support.Supports.ofSingleton | {
"commit": "66f4e3291020d4198ca6ede816acae5cee584a07",
"date": "2025-01-06T00:00:00"
} | {
"commit": "1c08486feb882444888c228ce1501e92bb85e0e2",
"date": "2025-01-07T00:00:00"
} | ConNF/ConNF/External/WellOrder.lean | ConNF.External.WellOrder | ConNF.External.WellOrder.jsonl | {
"lineInFile": 113,
"tokenPositionInFile": 3749,
"theoremPositionInFile": 6
} | {
"inFilePremises": false,
"numInFilePremises": 0,
"repositoryPremises": true,
"numRepositoryPremises": 43,
"numPremises": 114
} | {
"hasProof": true,
"proof": ":= by\n refine ⟨?_, λ h ↦ by cases h⟩\n intro ρ hρ\n open scoped Pointwise in\n have := sUnion_singleton_symmetric_aux hγ hβ {y | y ∈' x} S ?_ ρ hρ\n · apply ConNF.ext hγ\n intro z\n simp only [Set.ext_iff, Set.mem_setOf_eq, Set.mem_smul_set_iff_inv_smul_mem] at this\n rw [mem_smul_iff', allPerm_inv_sderiv', this]\n · intro ρ hρ\n ext z\n simp only [Set.mem_smul_set_iff_inv_smul_mem, Set.mem_image, Set.mem_setOf_eq]\n have := h.supports ρ hρ\n simp only [smul_singleton, singleton_inj] at this\n constructor\n · rintro ⟨y, h₁, h₂⟩\n rw [← smul_eq_iff_eq_inv_smul, smul_singleton] at h₂\n refine ⟨_, ?_, h₂⟩\n rw [← this]\n simp only [mem_smul_iff', allPerm_inv_sderiv', inv_smul_smul]\n exact h₁\n · rintro ⟨y, h, rfl⟩\n refine ⟨(ρ ↘ hβ ↘ hγ)⁻¹ • y, ?_, ?_⟩\n · rwa [← allPerm_inv_sderiv', ← mem_smul_iff', this]\n · simp only [smul_singleton, allPerm_inv_sderiv']",
"proofType": "tactic",
"proofLengthLines": 24,
"proofLengthTokens": 920
} |
import ConNF.ModelData.PathEnumeration
/-!
# Supports
In this file, we define the notion of a support.
## Main declarations
* `ConNF.BaseSupport`: The type of supports of atoms.
* `ConNF.Support`: The type of supports of objects of arbitrary type indices.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}]
/-!
## Base supports
-/
structure BaseSupport where
atoms : Enumeration Atom
nearLitters : Enumeration NearLitter
namespace BaseSupport
instance : SuperA BaseSupport (Enumeration Atom) where
superA := atoms
instance : SuperN BaseSupport (Enumeration NearLitter) where
superN := nearLitters
@[simp]
theorem mk_atoms {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴬ = a :=
rfl
@[simp]
theorem mk_nearLitters {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴺ = N :=
rfl
theorem atoms_congr {S T : BaseSupport} (h : S = T) :
Sᴬ = Tᴬ :=
h ▸ rfl
theorem nearLitters_congr {S T : BaseSupport} (h : S = T) :
Sᴺ = Tᴺ :=
h ▸ rfl
@[ext]
theorem ext {S T : BaseSupport} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
instance : SMul BasePerm BaseSupport where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms (π : BasePerm) (S : BaseSupport) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters (π : BasePerm) (S : BaseSupport) :
(π • S)ᴺ = π • Sᴺ :=
rfl
@[simp]
theorem smul_atoms_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
@[simp]
theorem smul_nearLitters_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance : MulAction BasePerm BaseSupport where
one_smul S := by
apply ext
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
theorem smul_eq_smul_iff (π₁ π₂ : BasePerm) (S : BaseSupport) :
π₁ • S = π₂ • S ↔ (∀ a ∈ Sᴬ, π₁ • a = π₂ • a) ∧ (∀ N ∈ Sᴺ, π₁ • N = π₂ • N) := by
constructor
· intro h
constructor
· rintro a ⟨i, ha⟩
have := congr_arg (·ᴬ.rel i (π₁ • a)) h
simp only [smul_atoms, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴬ.rel_coinjective.coinjective ha (this.mp ha)
rw [eq_inv_smul_iff] at this
rw [this]
· rintro N ⟨i, hN⟩
have := congr_arg (·ᴺ.rel i (π₁ • N)) h
simp only [smul_nearLitters, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴺ.rel_coinjective.coinjective hN (this.mp hN)
rw [eq_inv_smul_iff] at this
rw [this]
· intro h
ext : 2
· rfl
· ext i a : 3
rw [smul_atoms, smul_atoms, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
· rfl
· ext i a : 3
rw [smul_nearLitters, smul_nearLitters, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
theorem smul_eq_iff (π : BasePerm) (S : BaseSupport) :
π • S = S ↔ (∀ a ∈ Sᴬ, π • a = a) ∧ (∀ N ∈ Sᴺ, π • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul] at this
exact this
noncomputable instance : Add BaseSupport where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_atoms (S T : BaseSupport) :
(S + T)ᴬ = Sᴬ + Tᴬ :=
rfl
@[simp]
theorem add_nearLitters (S T : BaseSupport) :
(S + T)ᴺ = Sᴺ + Tᴺ :=
rfl
end BaseSupport
def baseSupportEquiv : BaseSupport ≃ Enumeration Atom × Enumeration NearLitter where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_baseSupport : #BaseSupport = #μ := by
rw [Cardinal.eq.mpr ⟨baseSupportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq card_atom, card_enumeration_eq card_nearLitter, mul_eq_self aleph0_lt_μ.le]
/-!
## Structural supports
-/
structure Support (α : TypeIndex) where
atoms : Enumeration (α ↝ ⊥ × Atom)
nearLitters : Enumeration (α ↝ ⊥ × NearLitter)
namespace Support
variable {α β : TypeIndex}
instance : SuperA (Support α) (Enumeration (α ↝ ⊥ × Atom)) where
superA := atoms
instance : SuperN (Support α) (Enumeration (α ↝ ⊥ × NearLitter)) where
superN := nearLitters
@[simp]
theorem mk_atoms (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴬ = E :=
rfl
@[simp]
theorem mk_nearLitters (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴺ = F :=
rfl
instance : Derivative (Support α) (Support β) α β where
deriv S A := ⟨Sᴬ ⇘ A, Sᴺ ⇘ A⟩
instance : Coderivative (Support β) (Support α) α β where
coderiv S A := ⟨Sᴬ ⇗ A, Sᴺ ⇗ A⟩
instance : BotDerivative (Support α) BaseSupport α where
botDeriv S A := ⟨Sᴬ ⇘. A, Sᴺ ⇘. A⟩
botSderiv S := ⟨Sᴬ ↘., Sᴺ ↘.⟩
botDeriv_single S h := by dsimp only; rw [botDeriv_single, botDeriv_single]
@[simp]
theorem deriv_atoms {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴬ ⇘ A = (S ⇘ A)ᴬ :=
rfl
@[simp]
theorem deriv_nearLitters {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴺ ⇘ A = (S ⇘ A)ᴺ :=
rfl
@[simp]
theorem sderiv_atoms {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴬ ↘ h = (S ↘ h)ᴬ :=
rfl
@[simp]
theorem sderiv_nearLitters {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴺ ↘ h = (S ↘ h)ᴺ :=
rfl
@[simp]
theorem coderiv_atoms {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴬ ⇗ A = (S ⇗ A)ᴬ :=
rfl
@[simp]
theorem coderiv_nearLitters {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴺ ⇗ A = (S ⇗ A)ᴺ :=
rfl
@[simp]
theorem scoderiv_atoms {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴬ ↗ h = (S ↗ h)ᴬ :=
rfl
@[simp]
theorem scoderiv_nearLitters {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴺ ↗ h = (S ↗ h)ᴺ :=
rfl
@[simp]
theorem derivBot_atoms {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴬ ⇘. A = (S ⇘. A)ᴬ :=
rfl
@[simp]
theorem derivBot_nearLitters {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴺ ⇘. A = (S ⇘. A)ᴺ :=
rfl
theorem ext' {S T : Support α} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
@[ext]
theorem ext {S T : Support α} (h : ∀ A, S ⇘. A = T ⇘. A) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
rw [mk.injEq]
constructor
· apply Enumeration.ext_path
intro A
exact BaseSupport.atoms_congr (h A)
· apply Enumeration.ext_path
intro A
exact BaseSupport.nearLitters_congr (h A)
@[simp]
theorem deriv_derivBot {α : TypeIndex} (S : Support α)
(A : α ↝ β) (B : β ↝ ⊥) :
S ⇘ A ⇘. B = S ⇘. (A ⇘ B) :=
rfl
@[simp]
theorem coderiv_deriv_eq {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
S ⇗ A ⇘ A = S :=
ext' (Sᴬ.coderiv_deriv_eq A) (Sᴺ.coderiv_deriv_eq A)
theorem eq_of_atom_mem_scoderiv_botDeriv {α β : TypeIndex} {S : Support β} {A : α ↝ ⊥}
{h : β < α} {a : Atom} (ha : a ∈ (S ↗ h ⇘. A)ᴬ) :
∃ B : β ↝ ⊥, A = B ↗ h :=
Enumeration.eq_of_mem_scoderiv_botDeriv ha
theorem eq_of_nearLitter_mem_scoderiv_botDeriv {α β : TypeIndex} {S : Support β} {A : α ↝ ⊥}
{h : β < α} {N : NearLitter} (hN : N ∈ (S ↗ h ⇘. A)ᴺ) :
∃ B : β ↝ ⊥, A = B ↗ h :=
Enumeration.eq_of_mem_scoderiv_botDeriv hN
@[simp]
theorem scoderiv_botDeriv_eq {α β : TypeIndex} (S : Support β) (A : β ↝ ⊥) (h : β < α) :
S ↗ h ⇘. (A ↗ h) = S ⇘. A :=
BaseSupport.ext (Enumeration.scoderiv_botDeriv_eq _ _ _) (Enumeration.scoderiv_botDeriv_eq _ _ _)
@[simp]
theorem scoderiv_deriv_eq {α β γ : TypeIndex} (S : Support β) (A : β ↝ γ) (h : β < α) :
S ↗ h ⇘ (A ↗ h) = S ⇘ A := by
apply ext
intro B
simp only [deriv_derivBot, ← scoderiv_botDeriv_eq S (A ⇘ B) h, Path.coderiv_deriv']
@[simp]
theorem coderiv_inj {α β : TypeIndex} (S T : Support β) (A : α ↝ β) :
S ⇗ A = T ⇗ A ↔ S = T := by
constructor
swap
· rintro rfl
rfl
intro h
ext B : 1
have : S ⇗ A ⇘ A ⇘. B = T ⇗ A ⇘ A ⇘. B := by rw [h]
rwa [coderiv_deriv_eq, coderiv_deriv_eq] at this
@[simp]
theorem scoderiv_inj {α β : TypeIndex} (S T : Support β) (h : β < α) :
S ↗ h = T ↗ h ↔ S = T :=
coderiv_inj S T (.single h)
instance {α : TypeIndex} : SMul (StrPerm α) (Support α) where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms {α : TypeIndex} (π : StrPerm α) (S : Support α) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters {α : TypeIndex} (π : StrPerm α) (S : Support α) :
(π • S)ᴺ = π • Sᴺ :=
rfl
theorem smul_atoms_eq_of_smul_eq {α : TypeIndex} {π : StrPerm α} {S : Support α}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
theorem smul_nearLitters_eq_of_smul_eq {α : TypeIndex} {π : StrPerm α} {S : Support α}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance {α : TypeIndex} : MulAction (StrPerm α) (Support α) where
one_smul S := by
apply ext'
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext'
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
@[simp]
theorem smul_derivBot {α : TypeIndex} (π : StrPerm α) (S : Support α) (A : α ↝ ⊥) :
(π • S) ⇘. A = π A • (S ⇘. A) :=
rfl
theorem smul_coderiv {α : TypeIndex} (π : StrPerm α) (S : Support β) (A : α ↝ β) :
π • S ⇗ A = (π ⇘ A • S) ⇗ A := by
ext B i x
· rfl
· constructor
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, x⟩, hS, rfl⟩
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, _⟩, hS, rfl⟩
· rfl
· constructor
· rintro ⟨⟨C, x⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, x⟩, hS, rfl⟩
· rintro ⟨⟨C, a⟩, hS, hx⟩
simp only [Prod.mk.injEq] at hx
obtain ⟨rfl, rfl⟩ := hx
exact ⟨⟨C, _⟩, hS, rfl⟩
theorem smul_scoderiv {α : TypeIndex} (π : StrPerm α) (S : Support β) (h : β < α) :
π • S ↗ h = (π ↘ h • S) ↗ h :=
smul_coderiv π S (Path.single h)
theorem smul_eq_smul_iff (π₁ π₂ : StrPerm β) (S : Support β) :
π₁ • S = π₂ • S ↔
∀ A, (∀ a ∈ (S ⇘. A)ᴬ, π₁ A • a = π₂ A • a) ∧ (∀ N ∈ (S ⇘. A)ᴺ, π₁ A • N = π₂ A • N) := by
constructor
· intro h A
have := congr_arg (· ⇘. A) h
simp only [smul_derivBot, BaseSupport.smul_eq_smul_iff] at this
exact this
· intro h
apply ext
intro A
simp only [smul_derivBot, BaseSupport.smul_eq_smul_iff]
exact h A
theorem smul_eq_iff (π : StrPerm β) (S : Support β) :
π • S = S ↔ ∀ A, (∀ a ∈ (S ⇘. A)ᴬ, π A • a = a) ∧ (∀ N ∈ (S ⇘. A)ᴺ, π A • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul, Tree.one_apply] at this
exact this
noncomputable instance : Add (Support α) where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_derivBot (S T : Support α) (A : α ↝ ⊥) :
(S + T) ⇘. A = (S ⇘. A) + (T ⇘. A) :=
rfl
theorem smul_add (S T : Support α) (π : StrPerm α) :
π • (S + T) = π • S + π • T :=
rfl
theorem add_inj_of_bound_eq_bound {S T U V : Support α}
(ha : Sᴬ.bound = Tᴬ.bound) (hN : Sᴺ.bound = Tᴺ.bound)
(h' : S + U = T + V) : S = T ∧ U = V := by
have ha' := Enumeration.add_inj_of_bound_eq_bound ha (congr_arg (·ᴬ) h')
have hN' := Enumeration.add_inj_of_bound_eq_bound hN (congr_arg (·ᴺ) h')
constructor
· exact Support.ext' ha'.1 hN'.1
· exact Support.ext' ha'.2 hN'.2
end Support
def supportEquiv {α : TypeIndex} : Support α ≃
Enumeration (α ↝ ⊥ × Atom) × Enumeration (α ↝ ⊥ × NearLitter) where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_support {α : TypeIndex} : #(Support α) = #μ := by
rw [Cardinal.eq.mpr ⟨supportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq, card_enumeration_eq, mul_eq_self aleph0_lt_μ.le]
· rw [mk_prod, lift_id, lift_id, card_nearLitter,
mul_eq_right aleph0_lt_μ.le (card_path_lt' α ⊥).le (card_path_ne_zero α)]
· rw [mk_prod, lift_id, lift_id, card_atom,
mul_eq_right aleph0_lt_μ.le (card_path_lt' α ⊥).le (card_path_ne_zero α)]
/-!
## Orders on supports
-/
-- TODO: Is this order used?
instance : LE BaseSupport where
le S T := (∀ a ∈ Sᴬ, a ∈ Tᴬ) ∧ (∀ N ∈ Sᴺ, N ∈ Tᴺ)
instance : Preorder BaseSupport where
le_refl S := ⟨λ _ ↦ id, λ _ ↦ id⟩
le_trans S T U h₁ h₂ := ⟨λ a h ↦ h₂.1 _ (h₁.1 a h), λ N h ↦ h₂.2 _ (h₁.2 N h)⟩
theorem BaseSupport.smul_le_smul {S T : BaseSupport} (h : S ≤ T) (π : BasePerm) :
π • S ≤ π • T := by
constructor
· intro a
exact h.1 (π⁻¹ • a)
· intro N
exact h.2 (π⁻¹ • N)
theorem BaseSupport.le_add_right {S T : BaseSupport} :
S ≤ S + T := by
constructor
· intro a ha
simp only [Support.add_derivBot, BaseSupport.add_atoms, Enumeration.mem_add_iff]
exact Or.inl ha
· intro N hN
simp only [Support.add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
exact Or.inl hN
theorem BaseSupport.le_add_left {S T : BaseSupport} :
S ≤ T + S := by
constructor
· intro a ha
simp only [add_atoms, Enumeration.mem_add_iff]
exact Or.inr ha
· intro N hN
simp only [add_nearLitters, Enumeration.mem_add_iff]
exact Or.inr hN
def BaseSupport.Subsupport (S T : BaseSupport) : Prop :=
Sᴬ.rel ≤ Tᴬ.rel ∧ Sᴺ.rel ≤ Tᴺ.rel
theorem BaseSupport.Subsupport.le {S T : BaseSupport}
(h : S.Subsupport T) : S ≤ T := by
constructor
· rintro a ⟨i, hi⟩
exact ⟨i, h.1 i a hi⟩
· rintro N ⟨i, hi⟩
exact ⟨i, h.2 i N hi⟩
theorem BaseSupport.Subsupport.trans {S T U : BaseSupport}
(h₁ : S.Subsupport T) (h₂ : T.Subsupport U) :
S.Subsupport U :=
⟨h₁.1.trans h₂.1, h₁.2.trans h₂.2⟩
theorem BaseSupport.smul_subsupport_smul {S T : BaseSupport} (h : S.Subsupport T) (π : BasePerm) :
(π • S).Subsupport (π • T) := by
constructor
· intro i a ha
exact h.1 i _ ha
· intro i N hN
exact h.2 i _ hN
instance {α : TypeIndex} : LE (Support α) where
le S T := ∀ A, S ⇘. A ≤ T ⇘. A
instance {α : TypeIndex} : Preorder (Support α) where
le_refl S := λ A ↦ le_rfl
le_trans S T U h₁ h₂ := λ A ↦ (h₁ A).trans (h₂ A)
theorem Support.smul_le_smul {α : TypeIndex} {S T : Support α} (h : S ≤ T) (π : StrPerm α) :
π • S ≤ π • T :=
λ A ↦ BaseSupport.smul_le_smul (h A) (π A)
| theorem Support.le_add_right {α : TypeIndex} {S T : Support α} :
S ≤ S + T | ConNF.Support.le_add_right | {
"commit": "39c33b4a743bea62dbcc549548b712ffd38ca65c",
"date": "2024-12-05T00:00:00"
} | {
"commit": "251ac752f844dfde539ac2bd3ff112305ad59139",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/ModelData/Support.lean | ConNF.ModelData.Support | ConNF.ModelData.Support.jsonl | {
"lineInFile": 532,
"tokenPositionInFile": 14912,
"theoremPositionInFile": 57
} | {
"inFilePremises": true,
"numInFilePremises": 9,
"repositoryPremises": true,
"numRepositoryPremises": 14,
"numPremises": 23
} | {
"hasProof": true,
"proof": ":= by\n intro A\n rw [add_derivBot]\n exact BaseSupport.le_add_right",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 68
} |
import ConNF.Model.TTT
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal
namespace ConNF
variable [Params.{u}] {α β γ δ ε ζ : Λ} (hβ : (β : TypeIndex) < α) (hγ : (γ : TypeIndex) < β)
(hδ : (δ : TypeIndex) < γ) (hε : (ε : TypeIndex) < δ) (hζ : (ζ : TypeIndex) < ε)
namespace TSet
theorem exists_inter (x y : TSet α) :
∃ w : TSet α, ∀ z : TSet β, z ∈[hβ] w ↔ z ∈[hβ] x ∧ z ∈[hβ] y := by
refine exists_of_symmetric {z | z ∈[hβ] x ∧ z ∈[hβ] y} hβ ?_
obtain ⟨S, hS⟩ := symmetric x hβ
obtain ⟨T, hT⟩ := symmetric y hβ
use S + T
intro ρ hρ
specialize hS ρ (smul_eq_of_le Support.le_add_right hρ)
specialize hT ρ (smul_eq_of_le Support.le_add_left hρ)
simp [Set.ext_iff, Set.mem_smul_set_iff_inv_smul_mem] at hS hT ⊢
aesop
theorem exists_compl (x : TSet α) :
∃ y : TSet α, ∀ z : TSet β, z ∈[hβ] y ↔ ¬z ∈[hβ] x := by
refine exists_of_symmetric {z | ¬z ∈[hβ] x} hβ ?_
obtain ⟨S, hS⟩ := symmetric x hβ
use S
intro ρ hρ
specialize hS ρ hρ
simp [Set.ext_iff, Set.mem_smul_set_iff_inv_smul_mem] at hS ⊢
aesop
theorem exists_up (x y : TSet β) :
∃ w : TSet α, ∀ z : TSet β, z ∈[hβ] w ↔ z = x ∨ z = y := by
refine exists_of_symmetric {x, y} hβ ?_
obtain ⟨S, hS⟩ := exists_support x
obtain ⟨T, hT⟩ := exists_support y
use (S + T) ↗ hβ
intro ρ hρ
rw [Support.smul_scoderiv, Support.scoderiv_inj, ← allPermSderiv_forget'] at hρ
specialize hS (ρ ↘ hβ) (smul_eq_of_le Support.le_add_right hρ)
specialize hT (ρ ↘ hβ) (smul_eq_of_le Support.le_add_left hρ)
simp only [Set.smul_set_def, Set.image, Set.mem_insert_iff, Set.mem_singleton_iff,
exists_eq_or_imp, hS, exists_eq_left, hT]
ext z
rw [Set.mem_insert_iff, Set.mem_singleton_iff, Set.mem_setOf_eq]
aesop
/-- The unordered pair. -/
def up (x y : TSet β) : TSet α :=
(exists_up hβ x y).choose
@[simp]
theorem mem_up_iff (x y z : TSet β) :
z ∈[hβ] up hβ x y ↔ z = x ∨ z = y :=
(exists_up hβ x y).choose_spec z
/-- The Kuratowski ordered pair. -/
def op (x y : TSet γ) : TSet α :=
up hβ (singleton hγ x) (up hγ x y)
theorem up_injective {x y z w : TSet β} (h : up hβ x y = up hβ z w) :
(x = z ∧ y = w) ∨ (x = w ∧ y = z) := by
have h₁ := mem_up_iff hβ x y z
have h₂ := mem_up_iff hβ x y w
have h₃ := mem_up_iff hβ z w x
have h₄ := mem_up_iff hβ z w y
rw [h, mem_up_iff] at h₁ h₂
rw [← h, mem_up_iff] at h₃ h₄
aesop
@[simp]
theorem up_inj (x y z w : TSet β) :
up hβ x y = up hβ z w ↔ (x = z ∧ y = w) ∨ (x = w ∧ y = z) := by
constructor
· exact up_injective hβ
· rintro (⟨rfl, rfl⟩ | ⟨rfl, rfl⟩)
· rfl
· apply tSet_ext' hβ
aesop
@[simp]
theorem up_self {x : TSet β} :
up hβ x x = singleton hβ x := by
apply tSet_ext' hβ
aesop
@[simp]
theorem up_eq_singleton_iff (x y z : TSet β) :
up hβ x y = singleton hβ z ↔ x = z ∧ y = z := by
constructor
· intro h
have h₁ := typedMem_singleton_iff' hβ z x
have h₂ := typedMem_singleton_iff' hβ z y
rw [← h, mem_up_iff] at h₁ h₂
aesop
· rintro ⟨rfl, rfl⟩
rw [up_self]
| @[simp]
theorem singleton_eq_up_iff (x y z : TSet β) :
singleton hβ z = up hβ x y ↔ x = z ∧ y = z | ConNF.TSet.singleton_eq_up_iff | {
"commit": "f804f5c71cfaa98223fc227dd822801e8bf77004",
"date": "2024-03-30T00:00:00"
} | {
"commit": "79d0b7460f1a514629674a45c428d31c1a50bb03",
"date": "2024-12-01T00:00:00"
} | ConNF/ConNF/Model/Hailperin.lean | ConNF.Model.Hailperin | ConNF.Model.Hailperin.jsonl | {
"lineInFile": 114,
"tokenPositionInFile": 3103,
"theoremPositionInFile": 10
} | {
"inFilePremises": true,
"numInFilePremises": 2,
"repositoryPremises": true,
"numRepositoryPremises": 10,
"numPremises": 30
} | {
"hasProof": true,
"proof": ":= by\n rw [← up_eq_singleton_iff hβ x y z, eq_comm]",
"proofType": "tactic",
"proofLengthLines": 1,
"proofLengthTokens": 52
} |
import ConNF.Model.RunInduction
/-!
# Externalisation
In this file, we convert many of our *internal* results (i.e. inside the induction) to *external*
ones (i.e. defined using the global `TSet`/`AllPerm` definitions).
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal WithBot
namespace ConNF
variable [Params.{u}]
instance globalModelData : {α : TypeIndex} → ModelData α
| (α : Λ) => (motive α).data
| ⊥ => botModelData
instance globalPosition : {α : TypeIndex} → Position (Tangle α)
| (α : Λ) => (motive α).pos
| ⊥ => botPosition
instance globalTypedNearLitters {α : Λ} : TypedNearLitters α :=
(motive α).typed
instance globalLtData [Level] : LtData where
instance globalLeData [Level] : LeData where
omit [Params] in
theorem heq_funext {α : Sort _} {β γ : α → Sort _} {f : (x : α) → β x} {g : (x : α) → γ x}
(h : ∀ x, HEq (f x) (g x)) : HEq f g := by
cases funext λ x ↦ type_eq_of_heq (h x)
simp only [heq_eq_eq] at h ⊢
exact funext h
theorem globalLtData_eq [Level] :
globalLtData = ltData (λ β _ ↦ motive β) := by
apply LtData.ext
· ext β hβ
induction β using recBotCoe
case bot => rfl
case coe β => rfl
· apply heq_funext
intro β
induction β using recBotCoe
case bot => rfl
case coe β => rfl
· rfl
theorem globalLeData_eq [Level] :
globalLeData = leData (λ β _ ↦ motive β) := by
apply LeData.ext
· ext β hβ
induction β using recBotCoe
case bot => rfl
case coe β =>
by_cases h : (β : TypeIndex) = α
· cases coe_injective h
rw [leData_data_eq]
unfold globalLeData globalModelData
dsimp only
rw [motive_eq]
rfl
· rw [leData_data_lt _ (hβ.elim.lt_of_ne h)]
rfl
· apply heq_funext
intro β
apply heq_funext
intro hβ
induction β using recBotCoe
case bot => rfl
case coe β =>
rw [leData]
simp only [coe_inj, id_eq, eq_mpr_eq_cast, recBotCoe_bot, recBotCoe_coe, LtLevel.elim.ne]
exact HEq.symm (cast_heq _ _)
instance globalPreCoherentData [Level] : PreCoherentData where
allPermSderiv h := cast (by rw [globalLeData_eq])
((preCoherentData (λ β _ ↦ motive β) (λ β _ ↦ hypothesis β)).allPermSderiv h)
singleton h := cast (by rw [globalLeData_eq])
((preCoherentData (λ β _ ↦ motive β) (λ β _ ↦ hypothesis β)).singleton h)
omit [Params] in
@[simp]
theorem heq_cast_eq_iff {α β γ : Type _} {x : α} {y : β} {h : α = γ} :
HEq (cast h x) y ↔ HEq x y := by
cases h
rw [cast_eq]
| theorem globalPreCoherentData_eq [Level] :
globalPreCoherentData = preCoherentData (λ β _ ↦ motive β) (λ β _ ↦ hypothesis β) | ConNF.globalPreCoherentData_eq | {
"commit": "6fdc87c6b30b73931407a372f1430ecf0fef7601",
"date": "2024-12-03T00:00:00"
} | {
"commit": "e409f3d0cd939e7218c3f39dcf3493c4b6e0b821",
"date": "2024-11-29T00:00:00"
} | ConNF/ConNF/Model/Externalise.lean | ConNF.Model.Externalise | ConNF.Model.Externalise.jsonl | {
"lineInFile": 99,
"tokenPositionInFile": 2555,
"theoremPositionInFile": 4
} | {
"inFilePremises": true,
"numInFilePremises": 5,
"repositoryPremises": true,
"numRepositoryPremises": 36,
"numPremises": 61
} | {
"hasProof": true,
"proof": ":= by\n have := globalLeData_eq\n rw [LeData.ext_iff] at this\n apply PreCoherentData.ext\n · exact this.1\n · exact this.2\n · unfold globalPreCoherentData\n apply heq_funext; intro β\n apply heq_funext; intro γ\n apply heq_funext; intro hβ\n apply heq_funext; intro hγ\n apply heq_funext; intro hβγ\n simp only [heq_cast_eq_iff]\n rfl\n · unfold globalPreCoherentData\n apply heq_funext; intro β\n apply heq_funext; intro γ\n apply heq_funext; intro hβ\n apply heq_funext; intro hγ\n apply heq_funext; intro hβγ\n simp only [heq_cast_eq_iff]\n rfl",
"proofType": "tactic",
"proofLengthLines": 21,
"proofLengthTokens": 577
} |
import ConNF.Model.Externalise
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal
namespace ConNF
variable [Params.{u}] {β γ : Λ} {hγ : (γ : TypeIndex) < β}
namespace Support
| theorem not_mem_scoderiv_botDeriv (S : Support γ) (N : NearLitter) :
N ∉ (S ↗ hγ ⇘. (Path.nil ↘.))ᴺ | ConNF.Support.not_mem_scoderiv_botDeriv | {
"commit": "abf71bc79c407ceb462cc2edd2d994cda9cdef05",
"date": "2024-04-04T00:00:00"
} | {
"commit": "251ac752f844dfde539ac2bd3ff112305ad59139",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/Model/RaiseStrong.lean | ConNF.Model.RaiseStrong | ConNF.Model.RaiseStrong.jsonl | {
"lineInFile": 24,
"tokenPositionInFile": 274,
"theoremPositionInFile": 0
} | {
"inFilePremises": false,
"numInFilePremises": 0,
"repositoryPremises": true,
"numRepositoryPremises": 32,
"numPremises": 71
} | {
"hasProof": true,
"proof": ":= by\n rintro ⟨i, ⟨A, N'⟩, h₁, h₂⟩\n simp only [Prod.mk.injEq] at h₂\n cases A\n case sderiv δ A hδ _ =>\n simp only [Path.deriv_sderiv] at h₂\n cases A\n case nil => cases h₂.1\n case sderiv ζ A hζ _ =>\n simp only [Path.deriv_sderiv] at h₂\n cases h₂.1",
"proofType": "tactic",
"proofLengthLines": 10,
"proofLengthTokens": 271
} |
import ConNF.Model.RaiseStrong
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal
open scoped Pointwise
namespace ConNF
variable [Params.{u}]
/-- A redefinition of the derivative of allowable permutations that is invariant of level,
but still has nice definitional properties. -/
@[default_instance 200]
instance {β γ : TypeIndex} : Derivative (AllPerm β) (AllPerm γ) β γ where
deriv ρ A :=
A.recSderiv
(motive := λ (δ : TypeIndex) (A : β ↝ δ) ↦
letI : Level := ⟨δ.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel δ := ⟨δ.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show δ.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
AllPerm δ)
ρ (λ δ ε A h ρ ↦
letI : Level := ⟨δ.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel δ := ⟨δ.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show δ.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
letI : LeLevel ε := ⟨h.le.trans LeLevel.elim⟩
PreCoherentData.allPermSderiv h ρ)
@[simp]
theorem allPerm_deriv_nil' {β : TypeIndex}
(ρ : AllPerm β) :
ρ ⇘ (.nil : β ↝ β) = ρ :=
rfl
@[simp]
theorem allPerm_deriv_sderiv' {β γ δ : TypeIndex}
(ρ : AllPerm β) (A : β ↝ γ) (h : δ < γ) :
ρ ⇘ (A ↘ h) = ρ ⇘ A ↘ h :=
rfl
@[simp]
theorem allPermSderiv_forget' {β γ : TypeIndex} (h : γ < β) (ρ : AllPerm β) :
(ρ ↘ h)ᵁ = ρᵁ ↘ h :=
letI : Level := ⟨β.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel β := ⟨β.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show β.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
letI : LeLevel γ := ⟨h.le.trans LeLevel.elim⟩
allPermSderiv_forget h ρ
@[simp]
theorem allPerm_inv_sderiv' {β γ : TypeIndex} (h : γ < β) (ρ : AllPerm β) :
ρ⁻¹ ↘ h = (ρ ↘ h)⁻¹ := by
apply allPermForget_injective
rw [allPermSderiv_forget', allPermForget_inv, Tree.inv_sderiv, allPermForget_inv,
allPermSderiv_forget']
def Symmetric {α β : Λ} (s : Set (TSet β)) (hβ : (β : TypeIndex) < α) : Prop :=
∃ S : Support α, ∀ ρ : AllPerm α, ρᵁ • S = S → ρ ↘ hβ • s = s
def newSetEquiv {α : Λ} :
letI : Level := ⟨α⟩
@TSet _ α newModelData.toPreModelData ≃ TSet α :=
letI : Level := ⟨α⟩
castTSet (D₁ := newModelData) (D₂ := globalModelData) rfl
(by rw [globalModelData, motive_eq, constructMotive, globalLtData_eq])
@[simp]
theorem newSetEquiv_forget {α : Λ}
(x : letI : Level := ⟨α⟩; @TSet _ α newModelData.toPreModelData) :
(newSetEquiv x)ᵁ = xᵁ :=
letI : Level := ⟨α⟩
castTSet_forget (D₁ := newModelData) (D₂ := globalModelData) _ x
def allPermEquiv {α : Λ} :
letI : Level := ⟨α⟩
NewPerm ≃ AllPerm α :=
letI : Level := ⟨α⟩
castAllPerm (D₁ := newModelData) (D₂ := globalModelData) rfl
(by rw [globalModelData, motive_eq, constructMotive, globalLtData_eq])
@[simp]
theorem allPermEquiv_forget {α : Λ} (ρ : letI : Level := ⟨α⟩; NewPerm) :
(allPermEquiv ρ)ᵁ = ρᵁ :=
letI : Level := ⟨α⟩
castAllPerm_forget (D₁ := newModelData) (D₂ := globalModelData) _ ρ
theorem allPermEquiv_sderiv {α β : Λ}
(ρ : letI : Level := ⟨α⟩; NewPerm) (hβ : (β : TypeIndex) < α) :
letI : Level := ⟨α⟩
letI : LtLevel β := ⟨hβ⟩
allPermEquiv ρ ↘ hβ = ρ.sderiv β := by
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
letI : LtLevel β := ⟨hβ⟩
apply allPermForget_injective
rw [allPermSderiv_forget, allPermEquiv_forget, NewPerm.forget_sderiv]
theorem TSet.exists_of_symmetric {α β : Λ} (s : Set (TSet β)) (hβ : (β : TypeIndex) < α)
(hs : Symmetric s hβ) :
∃ x : TSet α, ∀ y : TSet β, y ∈[hβ] x ↔ y ∈ s := by
letI : Level := ⟨α⟩
letI : LtLevel β := ⟨hβ⟩
suffices ∃ x : (@TSet _ α newModelData.toPreModelData), ∀ y : TSet β, yᵁ ∈[hβ] xᵁ ↔ y ∈ s by
obtain ⟨x, hx⟩ := this
use newSetEquiv x
intro y
rw [← hx, ← TSet.forget_mem_forget, newSetEquiv_forget]
obtain rfl | hs' := s.eq_empty_or_nonempty
· use none
intro y
simp only [Set.mem_empty_iff_false, iff_false]
exact not_mem_none y
· use some (Code.toSet ⟨β, s, hs'⟩ ?_)
· intro y
erw [mem_some_iff]
exact Code.mem_toSet _
· obtain ⟨S, hS⟩ := hs
use S
intro ρ hρS
have := hS (allPermEquiv ρ) ?_
· simp only [NewPerm.smul_mk, Code.mk.injEq, heq_eq_eq, true_and]
rwa [allPermEquiv_sderiv] at this
· rwa [allPermEquiv_forget]
theorem TSet.exists_support {α : Λ} (x : TSet α) :
∃ S : Support α, ∀ ρ : AllPerm α, ρᵁ • S = S → ρ • x = x := by
letI : Level := ⟨α⟩
obtain ⟨S, hS⟩ := NewSet.exists_support (newSetEquiv.symm x)
use S
intro ρ hρ
have := @Support.Supports.supports _ _ _ newPreModelData _ _ _ hS (allPermEquiv.symm ρ) ?_
· apply tSetForget_injective
have := congr_arg (·ᵁ) this
simp only at this
erw [@smul_forget _ _ newModelData (allPermEquiv.symm ρ) (newSetEquiv.symm x),
← allPermEquiv_forget, ← newSetEquiv_forget, Equiv.apply_symm_apply,
Equiv.apply_symm_apply] at this
rwa [smul_forget]
· rwa [← allPermEquiv_forget, Equiv.apply_symm_apply]
theorem TSet.symmetric {α β : Λ} (x : TSet α) (hβ : (β : TypeIndex) < α) :
Symmetric {y : TSet β | y ∈[hβ] x} hβ := by
obtain ⟨S, hS⟩ := exists_support x
use S
intro ρ hρ
conv_rhs => rw [← hS ρ hρ]
simp only [← forget_mem_forget, smul_forget, StrSet.mem_smul_iff]
ext y
rw [Set.mem_smul_set_iff_inv_smul_mem, Set.mem_setOf_eq, Set.mem_setOf_eq,
smul_forget, allPermForget_inv, allPermSderiv_forget']
theorem tSet_ext' {α β : Λ} (hβ : (β : TypeIndex) < α) (x y : TSet α)
(h : ∀ z : TSet β, z ∈[hβ] x ↔ z ∈[hβ] y) : x = y :=
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
letI : LtLevel β := ⟨hβ⟩
tSet_ext hβ x y h
@[simp]
theorem TSet.mem_smul_iff' {α β : TypeIndex}
{x : TSet β} {y : TSet α} (h : β < α) (ρ : AllPerm α) :
x ∈[h] ρ • y ↔ ρ⁻¹ ↘ h • x ∈[h] y := by
letI : Level := ⟨α.recBotCoe (Nonempty.some inferInstance) id⟩
letI : LeLevel α := ⟨α.recBotCoe (λ _ ↦ bot_le) (λ _ h ↦ WithBot.coe_le_coe.mpr h.le)
(show α.recBotCoe (Nonempty.some inferInstance) id = Level.α from rfl)⟩
letI : LtLevel β := ⟨h.trans_le LeLevel.elim⟩
exact mem_smul_iff h ρ -- For some reason, using `exact` instead of term mode speeds this up!
def singleton {α β : Λ} (hβ : (β : TypeIndex) < α) (x : TSet β) : TSet α :=
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
letI : LtLevel β := ⟨hβ⟩
PreCoherentData.singleton hβ x
@[simp]
theorem typedMem_singleton_iff' {α β : Λ} (hβ : (β : TypeIndex) < α) (x y : TSet β) :
y ∈[hβ] singleton hβ x ↔ y = x :=
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
letI : LtLevel β := ⟨hβ⟩
typedMem_singleton_iff hβ x y
@[simp]
theorem smul_singleton {α β : Λ} (hβ : (β : TypeIndex) < α) (x : TSet β) (ρ : AllPerm α) :
ρ • singleton hβ x = singleton hβ (ρ ↘ hβ • x) := by
apply tSet_ext' hβ
intro z
rw [TSet.mem_smul_iff', allPerm_inv_sderiv', typedMem_singleton_iff', typedMem_singleton_iff',
inv_smul_eq_iff]
theorem singleton_injective {α β : Λ} (hβ : (β : TypeIndex) < α) :
Function.Injective (singleton hβ) := by
intro x y hxy
have := typedMem_singleton_iff' hβ x y
rw [hxy, typedMem_singleton_iff'] at this
exact (this.mp rfl).symm
@[simp]
theorem singleton_inj {α β : Λ} {hβ : (β : TypeIndex) < α} {x y : TSet β} :
singleton hβ x = singleton hβ y ↔ x = y :=
(singleton_injective hβ).eq_iff
| theorem sUnion_singleton_symmetric_aux' {α β γ : Λ}
(hγ : (γ : TypeIndex) < β) (hβ : (β : TypeIndex) < α) (s : Set (TSet γ)) (S : Support α)
(hS : ∀ ρ : AllPerm α, ρᵁ • S = S → ρ ↘ hβ • singleton hγ '' s = singleton hγ '' s) :
letI : Level := ⟨α⟩
letI : LeLevel α := ⟨le_rfl⟩
∀ (ρ : AllPerm β), ρᵁ • S.strong ↘ hβ = S.strong ↘ hβ → ρ ↘ hγ • s ⊆ s | ConNF.sUnion_singleton_symmetric_aux' | {
"commit": "6fdc87c6b30b73931407a372f1430ecf0fef7601",
"date": "2024-12-03T00:00:00"
} | {
"commit": "1c08486feb882444888c228ce1501e92bb85e0e2",
"date": "2025-01-07T00:00:00"
} | ConNF/ConNF/Model/TTT.lean | ConNF.Model.TTT | ConNF.Model.TTT.jsonl | {
"lineInFile": 216,
"tokenPositionInFile": 7508,
"theoremPositionInFile": 20
} | {
"inFilePremises": true,
"numInFilePremises": 5,
"repositoryPremises": true,
"numRepositoryPremises": 43,
"numPremises": 94
} | {
"hasProof": true,
"proof": ":= by\n letI : Level := ⟨α⟩\n letI : LeLevel α := ⟨le_rfl⟩\n letI : LtLevel β := ⟨hβ⟩\n rintro ρ hρ _ ⟨x, hx, rfl⟩\n obtain ⟨T, hT⟩ := exists_support x\n obtain ⟨ρ', hρ'₁, hρ'₂⟩ := Support.exists_allowable_of_fixes S.strong S.strong_strong T ρ hγ hρ\n have hρ's := hS ρ' (smul_eq_of_le (S.subsupport_strong.le) hρ'₁)\n have hρ'x : ρ' ↘ hβ ↘ hγ • x = ρ ↘ hγ • x := by\n apply hT.smul_eq_smul\n simp only [allPermSderiv_forget', allPermSderiv_forget, WithBot.recBotCoe_coe, id_eq, hρ'₂]\n dsimp only\n rw [← hρ'x]\n have := (Set.ext_iff.mp hρ's (ρ' ↘ hβ • singleton hγ x)).mp ⟨_, Set.mem_image_of_mem _ hx, rfl⟩\n rw [smul_singleton] at this\n rwa [(singleton_injective hγ).mem_set_image] at this",
"proofType": "tactic",
"proofLengthLines": 15,
"proofLengthTokens": 698
} |
import ConNF.Background.Rel
import ConNF.Base.Small
/-!
# Enumerations
In this file, we define enumerations of a type.
## Main declarations
* `ConNF.Enumeration`: The type family of enumerations.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}] {X Y : Type u}
@[ext]
structure Enumeration (X : Type u) where
bound : κ
rel : Rel κ X
lt_bound : ∀ i ∈ rel.dom, i < bound
rel_coinjective : rel.Coinjective
variable {E F G : Enumeration X}
namespace Enumeration
instance : CoeTC (Enumeration X) (Set X) where
coe E := E.rel.codom
instance : Membership X (Enumeration X) where
mem E x := x ∈ E.rel.codom
theorem mem_iff (x : X) (E : Enumeration X) :
x ∈ E ↔ x ∈ E.rel.codom :=
Iff.rfl
theorem mem_congr {E F : Enumeration X} (h : E = F) :
∀ x, x ∈ E ↔ x ∈ F := by
intro x
rw [h]
theorem dom_small (E : Enumeration X) :
Small E.rel.dom :=
(iio_small E.bound).mono E.lt_bound
theorem coe_small (E : Enumeration X) :
Small (E : Set X) :=
small_codom_of_small_dom E.rel_coinjective E.dom_small
theorem graph'_small (E : Enumeration X) :
Small E.rel.graph' :=
small_graph' E.dom_small E.coe_small
noncomputable def empty : Enumeration X where
bound := 0
rel _ _ := False
lt_bound _ h := by cases h; contradiction
rel_coinjective := by constructor; intros; contradiction
@[simp]
theorem not_mem_empty (x : X) : x ∉ Enumeration.empty := by
rintro ⟨i, h⟩
cases h
noncomputable def singleton (x : X) : Enumeration X where
bound := 1
rel i y := i = 0 ∧ y = x
lt_bound i h := by
have : i = 0 := by simpa only [Rel.dom, exists_eq_right, Set.setOf_eq_eq_singleton,
Set.mem_singleton_iff] using h
rw [this, κEquiv_lt, ← Subtype.coe_lt_coe, κEquiv_ofNat, κEquiv_ofNat, Nat.cast_zero,
Nat.cast_one]
exact zero_lt_one
rel_coinjective := by
constructor
cc
@[simp]
theorem mem_singleton_iff (x y : X) :
y ∈ singleton x ↔ y = x := by
constructor
· rintro ⟨_, _, h⟩
exact h
· intro h
exact ⟨0, rfl, h⟩
theorem singleton_injective : Function.Injective (singleton : X → Enumeration X) := by
intro x y h
have := mem_singleton_iff y x
rw [← h, mem_singleton_iff] at this
exact this.mp rfl
/-!
## Cardinality bounds on enumerations
-/
end Enumeration
theorem card_enumeration_ge (X : Type u) : #X ≤ #(Enumeration X) :=
mk_le_of_injective Enumeration.singleton_injective
def enumerationEmbedding (X : Type u) : Enumeration X ↪ κ × {s : Set (κ × X) | Small s} where
toFun E := (E.bound, ⟨E.rel.graph', E.graph'_small⟩)
inj' := by
intro E F h
rw [Prod.mk.injEq, Subtype.mk.injEq] at h
exact Enumeration.ext h.1 (Rel.graph'_injective h.2)
theorem card_enumeration_le (h : #X ≤ #μ) : #(Enumeration X) ≤ #μ := by
apply (mk_le_of_injective (enumerationEmbedding X).injective).trans
rw [mk_prod, lift_id, lift_id]
apply mul_le_of_le aleph0_lt_μ.le κ_le_μ
apply card_small_le
rw [mk_prod, lift_id, lift_id]
exact mul_le_of_le aleph0_lt_μ.le κ_le_μ h
theorem card_enumeration_lt (h : #X < #μ) : #(Enumeration X) < #μ := by
apply (mk_le_of_injective (enumerationEmbedding X).injective).trans_lt
rw [mk_prod, lift_id, lift_id]
apply mul_lt_of_lt aleph0_lt_μ.le κ_lt_μ
apply (mk_subtype_le _).trans_lt
rw [mk_set]
apply μ_isStrongLimit.2
rw [mk_prod, lift_id, lift_id]
exact mul_lt_of_lt aleph0_lt_μ.le κ_lt_μ h
theorem card_enumeration_eq (h : #X = #μ) : #(Enumeration X) = #μ :=
le_antisymm (card_enumeration_le h.le) (h.symm.le.trans (card_enumeration_ge X))
namespace Enumeration
/-!
## Enumerations from sets
-/
theorem exists_equiv (s : Set X) (hs : Small s) :
Nonempty ((i : κ) × (s ≃ Set.Iio i)) := by
rw [Small] at hs
refine ⟨κEquiv.symm ⟨(#s).ord, ?_⟩, Nonempty.some ?_⟩
· rwa [Set.mem_Iio, ord_lt_ord]
· rw [← Cardinal.eq, Set.Iio, κ_card_Iio_eq, Equiv.apply_symm_apply, card_ord]
noncomputable def ofSet (s : Set X) (hs : Small s) : Enumeration X where
bound := (exists_equiv s hs).some.1
rel i x := ∃ h, i = (exists_equiv s hs).some.2 ⟨x, h⟩
lt_bound := by
rintro _ ⟨x, h, rfl⟩
exact ((exists_equiv s hs).some.2 ⟨x, h⟩).prop
rel_coinjective := by
constructor
rintro x y i ⟨hx, hix⟩ ⟨hy, hiy⟩
rw [hix] at hiy
cases (exists_equiv s hs).some.2.injective (Subtype.coe_injective hiy)
rfl
@[simp]
theorem mem_ofSet_iff (s : Set X) (hs : Small s) (x : X) :
x ∈ ofSet s hs ↔ x ∈ s := by
constructor
· rintro ⟨i, hx, _⟩
exact hx
· intro h
exact ⟨(exists_equiv s hs).some.2 ⟨x, h⟩, h, rfl⟩
@[simp]
theorem ofSet_coe (s : Set X) (hs : Small s) :
(ofSet s hs : Set X) = s := by
ext x
rw [← mem_ofSet_iff s hs]
rfl
/-!
## Operations on enumerations
-/
def image (E : Enumeration X) (f : X → Y) : Enumeration Y where
bound := E.bound
rel i y := ∃ x, E.rel i x ∧ f x = y
lt_bound := by
rintro i ⟨_, x, hi, rfl⟩
exact E.lt_bound i ⟨x, hi⟩
rel_coinjective := by
constructor
rintro i _ _ ⟨x₁, hx₁, rfl⟩ ⟨x₂, hx₂, rfl⟩
rw [E.rel_coinjective.coinjective hx₁ hx₂]
@[simp]
theorem image_bound {f : X → Y} :
(E.image f).bound = E.bound :=
rfl
theorem image_rel {f : X → Y} (i : κ) (y : Y) :
(E.image f).rel i y ↔ ∃ x, E.rel i x ∧ f x = y :=
Iff.rfl
@[simp]
theorem mem_image {f : X → Y} (y : Y) :
y ∈ E.image f ↔ y ∈ f '' E := by
constructor
· rintro ⟨i, x, hx, rfl⟩
exact ⟨x, ⟨i, hx⟩, rfl⟩
· rintro ⟨x, ⟨i, hx⟩, rfl⟩
exact ⟨i, x, hx, rfl⟩
def invImage (E : Enumeration X) (f : Y → X) (hf : f.Injective) : Enumeration Y where
bound := E.bound
rel i y := E.rel i (f y)
lt_bound := by
rintro i ⟨y, hy⟩
exact E.lt_bound i ⟨f y, hy⟩
rel_coinjective := by
constructor
intro i y₁ y₂ h₁ h₂
exact hf <| E.rel_coinjective.coinjective h₁ h₂
theorem invImage_rel {f : Y → X} {hf : f.Injective} (i : κ) (y : Y) :
(E.invImage f hf).rel i y ↔ E.rel i (f y) :=
Iff.rfl
@[simp]
theorem mem_invImage {f : Y → X} {hf : f.Injective} (y : Y) :
y ∈ E.invImage f hf ↔ f y ∈ E :=
Iff.rfl
def comp (E : Enumeration X) (r : Rel X Y) (hr : r.Coinjective) : Enumeration Y where
bound := E.bound
rel := E.rel.comp r
lt_bound := by
rintro i ⟨y, x, hy⟩
exact E.lt_bound i ⟨x, hy.1⟩
rel_coinjective := E.rel_coinjective.comp hr
instance {G X : Type _} [Group G] [MulAction G X] :
SMul G (Enumeration X) where
smul π E := E.invImage (λ x ↦ π⁻¹ • x) (MulAction.injective π⁻¹)
@[simp]
theorem smul_rel {G X : Type _} [Group G] [MulAction G X]
(π : G) (E : Enumeration X) (i : κ) (x : X) :
(π • E).rel i x ↔ E.rel i (π⁻¹ • x) :=
Iff.rfl
@[simp]
theorem mem_smul {G X : Type _} [Group G] [MulAction G X]
(π : G) (E : Enumeration X) (x : X) :
x ∈ π • E ↔ π⁻¹ • x ∈ E :=
Iff.rfl
@[simp]
theorem smul_rel_dom {G X : Type _} [Group G] [MulAction G X]
(π : G) (E : Enumeration X) :
(π • E).rel.dom = E.rel.dom := by
ext i
constructor
· rintro ⟨x, h⟩
exact ⟨π⁻¹ • x, h⟩
· rintro ⟨x, h⟩
use π • x
rwa [smul_rel, inv_smul_smul]
open scoped Pointwise in
@[simp]
theorem smul_rel_codom {G X : Type _} [Group G] [MulAction G X]
(π : G) (E : Enumeration X) :
(π • E).rel.codom = π • E.rel.codom := by
ext x
constructor
· rintro ⟨i, h⟩
exact ⟨π⁻¹ • x, ⟨i, h⟩, smul_inv_smul π x⟩
· rintro ⟨x, ⟨i, h⟩, rfl⟩
use i
rwa [smul_rel, inv_smul_smul]
open scoped Pointwise in
@[simp]
theorem smul_coe {G X : Type _} [Group G] [MulAction G X]
(π : G) (E : Enumeration X) :
((π • E : Enumeration X) : Set X) = π • (E : Set X) :=
smul_rel_codom π E
instance {G X : Type _} [Group G] [MulAction G X] :
MulAction G (Enumeration X) where
one_smul E := by
ext i x
· rfl
· rw [smul_rel, inv_one, one_smul]
mul_smul π₁ π₂ E := by
ext i x
· rfl
· rw [smul_rel, smul_rel, smul_rel, mul_inv_rev, mul_smul]
theorem mem_smul_iff {G X : Type _} [Group G] [MulAction G X] (x : X) (g : G) (E : Enumeration X) :
x ∈ g • E ↔ g⁻¹ • x ∈ E :=
Iff.rfl
theorem eq_of_smul_eq_smul {G X : Type _} [Group G] [MulAction G X] {g₁ g₂ : G} {E : Enumeration X}
(h : g₁ • E = g₂ • E) (x : X) (hx : x ∈ E) : g₁ • x = g₂ • x := by
obtain ⟨i, hi⟩ := hx
have : (g₁ • E).rel i (g₁ • x) := by rwa [smul_rel, inv_smul_smul]
rw [h] at this
have := E.rel_coinjective.coinjective hi this
exact (eq_inv_smul_iff.mp this).symm
theorem eq_of_smul_eq {G X : Type _} [Group G] [MulAction G X] {g : G} {E : Enumeration X}
(h : g • E = E) (x : X) (hx : x ∈ E) : g • x = x := by
have := eq_of_smul_eq_smul (g₁ := g) (g₂ := 1) ?_ x hx
· rwa [one_smul] at this
· rwa [one_smul]
@[simp]
theorem smul_singleton {G X : Type _} [Group G] [MulAction G X] {g : G} {x : X} :
g • singleton x = singleton (g • x) := by
apply Enumeration.ext
· rfl
· ext i y
rw [smul_rel]
simp only [singleton, and_congr_right_iff, inv_smul_eq_iff]
/-!
## Concatenation of enumerations
-/
noncomputable instance : Add (Enumeration X) where
add E F := {
bound := E.bound + F.bound
rel := E.rel ⊔ Rel.comp (E.bound + ·).graph.inv F.rel
lt_bound := by
rintro i ⟨x, hi | ⟨j, rfl, hjx⟩⟩
· exact (E.lt_bound i ⟨x, hi⟩).trans_le (κ_le_add E.bound F.bound)
· rw [add_lt_add_iff_left]
exact F.lt_bound j ⟨x, hjx⟩
rel_coinjective := by
constructor
rintro x y i (hix | ⟨j, hj, hjx⟩) (hiy | ⟨k, hk, hky⟩)
· exact E.rel_coinjective.coinjective hix hiy
· cases hk
have := E.lt_bound _ ⟨x, hix⟩
rw [add_lt_iff_neg_left] at this
cases (κ_zero_le k).not_lt this
· cases hj
have := E.lt_bound _ ⟨y, hiy⟩
rw [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
· cases hj
simp only [Rel.inv, flip, Function.graph_def, add_right_inj] at hk
cases hk
exact F.rel_coinjective.coinjective hjx hky
}
@[simp]
theorem add_bound (E F : Enumeration X) :
(E + F).bound = E.bound + F.bound :=
rfl
theorem rel_add_iff {E F : Enumeration X} (i : κ) (x : X) :
(E + F).rel i x ↔ E.rel i x ∨ ∃ j, E.bound + j = i ∧ F.rel j x :=
Iff.rfl
| theorem add_rel_dom {X : Type _} (E F : Enumeration X) :
(E + F).rel.dom = E.rel.dom ∪ (E.bound + ·) '' F.rel.dom | ConNF.Enumeration.add_rel_dom | {
"commit": "39c33b4a743bea62dbcc549548b712ffd38ca65c",
"date": "2024-12-05T00:00:00"
} | {
"commit": "6709914ae7f5cd3e2bb24b413e09aa844554d234",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/ModelData/Enumeration.lean | ConNF.ModelData.Enumeration | ConNF.ModelData.Enumeration.jsonl | {
"lineInFile": 365,
"tokenPositionInFile": 10091,
"theoremPositionInFile": 31
} | {
"inFilePremises": true,
"numInFilePremises": 5,
"repositoryPremises": true,
"numRepositoryPremises": 9,
"numPremises": 49
} | {
"hasProof": true,
"proof": ":= by\n ext i\n simp only [Rel.dom, rel_add_iff, Set.mem_setOf_eq, Set.mem_union, Set.mem_image]\n aesop",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 104
} |
import ConNF.Model.Hailperin
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal ConNF.TSet
namespace ConNF
variable [Params.{u}] {α β γ δ ε ζ : Λ} (hβ : (β : TypeIndex) < α) (hγ : (γ : TypeIndex) < β)
(hδ : (δ : TypeIndex) < γ) (hε : (ε : TypeIndex) < δ) (hζ : (ζ : TypeIndex) < ε)
theorem ext (x y : TSet α) :
(∀ z : TSet β, z ∈' x ↔ z ∈' y) → x = y :=
tSet_ext' hβ x y
def inter (x y : TSet α) : TSet α :=
(TSet.exists_inter hβ x y).choose
notation:69 x:69 " ⊓[" h "] " y:69 => _root_.ConNF.inter h x y
notation:69 x:69 " ⊓' " y:69 => x ⊓[by assumption] y
@[simp]
theorem mem_inter_iff (x y : TSet α) :
∀ z : TSet β, z ∈' x ⊓' y ↔ z ∈' x ∧ z ∈' y :=
(TSet.exists_inter hβ x y).choose_spec
def compl (x : TSet α) : TSet α :=
(TSet.exists_compl hβ x).choose
notation:1024 x:1024 " ᶜ[" h "]" => _root_.ConNF.compl h x
notation:1024 x:1024 " ᶜ'" => xᶜ[by assumption]
@[simp]
theorem mem_compl_iff (x : TSet α) :
∀ z : TSet β, z ∈' xᶜ' ↔ ¬z ∈' x :=
(TSet.exists_compl hβ x).choose_spec
notation:1024 "{" x "}[" h "]" => _root_.ConNF.singleton h x
notation:1024 "{" x "}'" => {x}[by assumption]
@[simp]
theorem mem_singleton_iff (x y : TSet β) :
y ∈' {x}' ↔ y = x :=
typedMem_singleton_iff' hβ x y
notation:1024 "{" x ", " y "}[" h "]" => _root_.ConNF.TSet.up h x y
notation:1024 "{" x ", " y "}'" => {x, y}[by assumption]
@[simp]
theorem mem_up_iff (x y z : TSet β) :
z ∈' {x, y}' ↔ z = x ∨ z = y :=
TSet.mem_up_iff hβ x y z
notation:1024 "⟨" x ", " y "⟩[" h ", " h' "]" => _root_.ConNF.TSet.op h h' x y
notation:1024 "⟨" x ", " y "⟩'" => ⟨x, y⟩[by assumption, by assumption]
theorem op_def (x y : TSet γ) :
(⟨x, y⟩' : TSet α) = { {x}', {x, y}' }' :=
rfl
def singletonImage' (x : TSet β) : TSet α :=
(TSet.exists_singletonImage hβ hγ hδ hε x).choose
@[simp]
theorem singletonImage'_spec (x : TSet β) :
∀ z w,
⟨ {z}', {w}' ⟩' ∈' singletonImage' hβ hγ hδ hε x ↔ ⟨z, w⟩' ∈' x :=
(TSet.exists_singletonImage hβ hγ hδ hε x).choose_spec
def insertion2' (x : TSet γ) : TSet α :=
(TSet.exists_insertion2 hβ hγ hδ hε hζ x).choose
@[simp]
theorem insertion2'_spec (x : TSet γ) :
∀ a b c, ⟨ { {a}' }', ⟨b, c⟩' ⟩' ∈' insertion2' hβ hγ hδ hε hζ x ↔
⟨a, c⟩' ∈' x :=
(TSet.exists_insertion2 hβ hγ hδ hε hζ x).choose_spec
def insertion3' (x : TSet γ) : TSet α :=
(TSet.exists_insertion3 hβ hγ hδ hε hζ x).choose
theorem insertion3'_spec (x : TSet γ) :
∀ a b c, ⟨ { {a}' }', ⟨b, c⟩' ⟩' ∈' insertion3' hβ hγ hδ hε hζ x ↔
⟨a, b⟩' ∈' x :=
(TSet.exists_insertion3 hβ hγ hδ hε hζ x).choose_spec
def vCross (x : TSet γ) : TSet α :=
(TSet.exists_cross hβ hγ hδ x).choose
@[simp]
theorem vCross_spec (x : TSet γ) :
∀ a, a ∈' vCross hβ hγ hδ x ↔ ∃ b c, a = ⟨b, c⟩' ∧ c ∈' x :=
(TSet.exists_cross hβ hγ hδ x).choose_spec
def typeLower (x : TSet α) : TSet δ :=
(TSet.exists_typeLower hβ hγ hδ hε x).choose
| @[simp]
theorem mem_typeLower_iff (x : TSet α) :
∀ a, a ∈' typeLower hβ hγ hδ hε x ↔ ∀ b, ⟨ b, {a}' ⟩' ∈' x | ConNF.mem_typeLower_iff | {
"commit": "b12701769822aaf5451982e26d7b7d1c2f21b137",
"date": "2024-04-11T00:00:00"
} | {
"commit": "66f4e3291020d4198ca6ede816acae5cee584a07",
"date": "2025-01-06T00:00:00"
} | ConNF/ConNF/Model/Result.lean | ConNF.Model.Result | ConNF.Model.Result.jsonl | {
"lineInFile": 109,
"tokenPositionInFile": 2983,
"theoremPositionInFile": 27
} | {
"inFilePremises": true,
"numInFilePremises": 1,
"repositoryPremises": true,
"numRepositoryPremises": 13,
"numPremises": 25
} | {
"hasProof": true,
"proof": ":=\n (TSet.exists_typeLower hβ hγ hδ hε x).choose_spec",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 54
} |
import ConNF.Base.TypeIndex
/-!
# Paths of type indices
In this file, we define the notion of a *path*, and the derivative and coderivative operations.
## Main declarations
* `ConNF.Path`: A path of type indices.
* `ConNF.Path.recSderiv`, `ConNF.Path.recSderivLe`, `ConNF.Path.recSderivGlobal`:
Downwards induction principles for paths.
* `ConNF.Path.recScoderiv`: An upwards induction principle for paths.
-/
universe u
open Cardinal WithBot
namespace ConNF
variable [Params.{u}] {α β γ δ : TypeIndex}
/-- A path of type indices starting at `α` and ending at `β` is a finite sequence of type indices
`α > ... > β`. -/
inductive Path (α : TypeIndex) : TypeIndex → Type u
| nil : Path α α
| cons {β γ : TypeIndex} : Path α β → γ < β → Path α γ
@[inherit_doc] infix:70 " ↝ " => Path
def Path.single {α β : TypeIndex} (h : β < α) : α ↝ β :=
.cons .nil h
/-- Typeclass for the `↘` notation. -/
class SingleDerivative (X : Type _) (Y : outParam <| Type _)
(β : outParam TypeIndex) (γ : TypeIndex) where
sderiv : X → γ < β → Y
/-- Typeclass for the `⇘` notation. -/
class Derivative (X : Type _) (Y : outParam <| Type _)
(β : outParam TypeIndex) (γ : TypeIndex) extends SingleDerivative X Y β γ where
deriv : X → β ↝ γ → Y
sderiv x h := deriv x (.single h)
deriv_single : ∀ x : X, ∀ h : γ < β, deriv x (.single h) = sderiv x h := by intros; rfl
/-- Typeclass for the `↘.` notation. -/
class BotSingleDerivative (X : Type _) (Y : outParam <| Type _) where
botSderiv : X → Y
/-- Typeclass for the `⇘.` notation. -/
class BotDerivative (X : Type _) (Y : outParam <| Type _) (β : outParam TypeIndex)
extends BotSingleDerivative X Y where
botDeriv : X → β ↝ ⊥ → Y
/-- We often need to do case analysis on `β` to show that it's a proper type index here.
This case check doesn't need to be done in most actual use cases of the notation. -/
botDeriv_single : ∀ x : X, ∀ h : ⊥ < β, botDeriv x (.single h) = botSderiv x
/-- Typeclass for the `↗` notation. -/
class SingleCoderivative (X : Type _) (Y : outParam <| Type _)
(β : TypeIndex) (γ : outParam TypeIndex) where
scoderiv : X → γ < β → Y
/-- Typeclass for the `⇗` notation. -/
class Coderivative (X : Type _) (Y : outParam <| Type _)
(β : TypeIndex) (γ : outParam TypeIndex) extends SingleCoderivative X Y β γ where
coderiv : X → β ↝ γ → Y
scoderiv x h := coderiv x (.single h)
coderiv_single : ∀ x : X, ∀ h : γ < β, coderiv x (.single h) = scoderiv x h := by intros; rfl
infixl:75 " ↘ " => SingleDerivative.sderiv
infixl:75 " ⇘ " => Derivative.deriv
postfix:75 " ↘." => BotSingleDerivative.botSderiv
infixl:75 " ⇘. " => BotDerivative.botDeriv
infixl:75 " ↗ " => SingleCoderivative.scoderiv
infixl:75 " ⇗ " => Coderivative.coderiv
@[simp]
theorem deriv_single {X Y : Type _} [Derivative X Y β γ] (x : X) (h : γ < β) :
x ⇘ .single h = x ↘ h :=
Derivative.deriv_single x h
@[simp]
theorem coderiv_single {X Y : Type _} [Coderivative X Y β γ] (x : X) (h : γ < β) :
x ⇗ .single h = x ↗ h :=
Coderivative.coderiv_single x h
@[simp]
theorem botDeriv_single {X Y : Type _} [BotDerivative X Y β] (x : X) (h : ⊥ < β) :
x ⇘. .single h = x ↘. :=
BotDerivative.botDeriv_single x h
/-!
## Downwards recursion along paths
-/
instance : SingleDerivative (α ↝ β) (α ↝ γ) β γ where
sderiv := .cons
/-- The downwards recursion principle for paths. -/
@[elab_as_elim, induction_eliminator, cases_eliminator]
def Path.recSderiv {motive : ∀ β, α ↝ β → Sort _}
(nil : motive α .nil)
(sderiv : ∀ β γ (A : α ↝ β) (h : γ < β), motive β A → motive γ (A ↘ h)) :
{β : TypeIndex} → (A : α ↝ β) → motive β A
| _, .nil => nil
| _, .cons A h => sderiv _ _ A h (recSderiv nil sderiv A)
@[simp]
theorem Path.recSderiv_nil {motive : ∀ β, α ↝ β → Sort _}
(nil : motive α .nil)
(sderiv : ∀ β γ (A : α ↝ β) (h : γ < β), motive β A → motive γ (A ↘ h)) :
recSderiv (motive := motive) nil sderiv .nil = nil :=
rfl
@[simp]
theorem Path.recSderiv_sderiv {motive : ∀ β, α ↝ β → Sort _}
(nil : motive α .nil)
(sderiv : ∀ β γ (A : α ↝ β) (h : γ < β), motive β A → motive γ (A ↘ h))
{β γ : TypeIndex} (A : α ↝ β) (h : γ < β) :
recSderiv (motive := motive) nil sderiv (A ↘ h) = sderiv β γ A h (recSderiv nil sderiv A) :=
rfl
theorem Path.le (A : α ↝ β) : β ≤ α := by
induction A with
| nil => exact le_rfl
| sderiv β γ _A h h' => exact h.le.trans h'
/-- The downwards recursion principle for paths, specialised to the case where the motive at `β`
only depends on the fact that `β ≤ α`. -/
def Path.recSderivLe {motive : ∀ β ≤ α, Sort _}
(nil : motive α le_rfl)
(sderiv : ∀ β γ, ∀ (A : α ↝ β) (h : γ < β), motive β A.le → motive γ (h.le.trans A.le)) :
{β : TypeIndex} → (A : α ↝ β) → motive β A.le :=
Path.recSderiv (motive := λ β A ↦ motive β A.le) nil sderiv
@[simp]
theorem Path.recSderivLe_nil {motive : ∀ β ≤ α, Sort _}
(nil : motive α le_rfl)
(sderiv : ∀ β γ (A : α ↝ β) (h : γ < β), motive β A.le → motive γ (h.le.trans A.le)) :
recSderivLe (motive := motive) nil sderiv .nil = nil :=
rfl
@[simp]
theorem Path.recSderivLe_sderiv {motive : ∀ β ≤ α, Sort _}
(nil : motive α le_rfl)
(sderiv : ∀ β γ (A : α ↝ β) (h : γ < β), motive β A.le → motive γ (h.le.trans A.le))
{β γ : TypeIndex} (A : α ↝ β) (h : γ < β) :
recSderivLe (motive := motive) nil sderiv (A ↘ h) = sderiv β γ A h (recSderiv nil sderiv A) :=
rfl
/-- The downwards recursion principle for paths, specialised to the case where the motive is not
dependent on the relation of `β` to `α`. -/
@[elab_as_elim]
def Path.recSderivGlobal {motive : TypeIndex → Sort _}
(nil : motive α)
(sderiv : ∀ β γ, α ↝ β → γ < β → motive β → motive γ) :
{β : TypeIndex} → α ↝ β → motive β :=
Path.recSderiv (motive := λ β _ ↦ motive β) nil sderiv
@[simp]
theorem Path.recSderivGlobal_nil {motive : TypeIndex → Sort _}
(nil : motive α)
(sderiv : ∀ β γ, α ↝ β → γ < β → motive β → motive γ) :
recSderivGlobal (motive := motive) nil sderiv .nil = nil :=
rfl
@[simp]
theorem Path.recSderivGlobal_sderiv {motive : TypeIndex → Sort _}
(nil : motive α)
(sderiv : ∀ β γ, α ↝ β → γ < β → motive β → motive γ)
{β γ : TypeIndex} (A : α ↝ β) (h : γ < β) :
recSderivGlobal (motive := motive) nil sderiv (A ↘ h) =
sderiv β γ A h (recSderiv nil sderiv A) :=
rfl
/-!
## Derivatives of paths
-/
instance : Derivative (α ↝ β) (α ↝ γ) β γ where
deriv A := Path.recSderivGlobal A (λ _ _ _ h B ↦ B ↘ h)
instance : BotDerivative (α ↝ β) (α ↝ ⊥) β where
botDeriv A B := A ⇘ B
botSderiv A :=
match β with
| ⊥ => A
| (β : Λ) => A ↘ bot_lt_coe β
botDeriv_single A h := by
cases β using WithBot.recBotCoe with
| bot => cases lt_irrefl ⊥ h
| coe => rfl
instance : Coderivative (β ↝ γ) (α ↝ γ) α β where
coderiv A B := B ⇘ A
@[simp]
theorem Path.deriv_nil (A : α ↝ β) :
A ⇘ .nil = A :=
rfl
@[simp]
theorem Path.deriv_sderiv (A : α ↝ β) (B : β ↝ γ) (h : δ < γ) :
A ⇘ (B ↘ h) = A ⇘ B ↘ h :=
rfl
@[simp]
theorem Path.nil_deriv (A : α ↝ β) :
(.nil : α ↝ α) ⇘ A = A := by
induction A with
| nil => rfl
| sderiv γ δ A h ih => rw [deriv_sderiv, ih]
@[simp]
theorem Path.deriv_sderivBot (A : α ↝ β) (B : β ↝ γ) :
A ⇘ (B ↘.) = A ⇘ B ↘. := by
cases γ using WithBot.recBotCoe with
| bot => rfl
| coe => rfl
@[simp]
theorem Path.botSderiv_bot_eq (A : α ↝ ⊥) :
A ↘. = A :=
rfl
@[simp]
theorem Path.botSderiv_coe_eq {β : Λ} (A : α ↝ β) :
A ↘ bot_lt_coe β = A ↘. :=
rfl
@[simp]
theorem Path.deriv_assoc (A : α ↝ β) (B : β ↝ γ) (C : γ ↝ δ) :
A ⇘ (B ⇘ C) = A ⇘ B ⇘ C := by
induction C with
| nil => rfl
| sderiv ε ζ C h ih => simp only [deriv_sderiv, ih]
@[simp]
theorem Path.deriv_sderiv_assoc (A : α ↝ β) (B : β ↝ γ) (h : δ < γ) :
A ⇘ (B ↘ h) = A ⇘ B ↘ h :=
rfl
@[simp]
theorem Path.deriv_scoderiv (A : α ↝ β) (B : γ ↝ δ) (h : γ < β) :
A ⇘ (B ↗ h) = A ↘ h ⇘ B := by
induction B with
| nil => rfl
| sderiv ε ζ B h' ih =>
rw [deriv_sderiv, ← ih]
rfl
@[simp]
theorem Path.botDeriv_scoderiv (A : α ↝ β) (B : γ ↝ ⊥) (h : γ < β) :
A ⇘. (B ↗ h) = A ↘ h ⇘. B :=
deriv_scoderiv A B h
theorem Path.coderiv_eq_deriv (A : α ↝ β) (B : β ↝ γ) :
B ⇗ A = A ⇘ B :=
rfl
theorem Path.coderiv_deriv (A : β ↝ γ) (h₁ : β < α) (h₂ : δ < γ) :
A ↗ h₁ ↘ h₂ = A ↘ h₂ ↗ h₁ :=
rfl
theorem Path.coderiv_deriv' (A : β ↝ γ) (h : β < α) (B : γ ↝ δ) :
A ↗ h ⇘ B = A ⇘ B ↗ h := by
induction B with
| nil => rfl
| sderiv ε ζ B h' ih =>
rw [deriv_sderiv, ih]
rfl
theorem Path.eq_nil (A : β ↝ β) :
A = .nil := by
cases A with
| nil => rfl
| sderiv γ _ A h => cases A.le.not_lt h
theorem Path.sderiv_index_injective {A : α ↝ β} {B : α ↝ γ} {hδβ : δ < β} {hδγ : δ < γ}
(h : A ↘ hδβ = B ↘ hδγ) :
β = γ := by
cases h
rfl
theorem Path.sderivBot_index_injective {β γ : Λ} {A : α ↝ β} {B : α ↝ γ}
(h : A ↘. = B ↘.) :
β = γ := by
cases h
rfl
theorem Path.sderiv_path_injective {A B : α ↝ β} {hγ : γ < β} (h : A ↘ hγ = B ↘ hγ) :
A = B := by
cases h
rfl
theorem Path.sderivBot_path_injective {β : Λ} {A B : α ↝ β} (h : A ↘. = B ↘.) :
A = B := by
cases h
rfl
theorem Path.deriv_left_injective {A B : α ↝ β} {C : β ↝ γ} (h : A ⇘ C = B ⇘ C) :
A = B := by
induction C with
| nil => exact h
| sderiv δ ε C hε ih =>
rw [deriv_sderiv_assoc, deriv_sderiv_assoc] at h
exact ih (Path.sderiv_path_injective h)
theorem Path.deriv_right_injective {A : α ↝ β} {B C : β ↝ γ} (h : A ⇘ B = A ⇘ C) :
B = C := by
induction C with
| nil => exact B.eq_nil
| sderiv δ ε C hε ih =>
cases B with
| nil => cases C.le.not_lt hε
| sderiv ζ η B hε' =>
cases Path.sderiv_index_injective h
rw [deriv_sderiv_assoc, deriv_sderiv_assoc] at h
rw [ih (Path.sderiv_path_injective h)]
@[simp]
theorem Path.sderiv_left_inj {A B : α ↝ β} {h : γ < β} :
A ↘ h = B ↘ h ↔ A = B :=
⟨Path.sderiv_path_injective, λ h ↦ h ▸ rfl⟩
@[simp]
theorem Path.deriv_left_inj {A B : α ↝ β} {C : β ↝ γ} :
A ⇘ C = B ⇘ C ↔ A = B :=
⟨deriv_left_injective, λ h ↦ h ▸ rfl⟩
@[simp]
theorem Path.deriv_right_inj {A : α ↝ β} {B C : β ↝ γ} :
A ⇘ B = A ⇘ C ↔ B = C :=
⟨deriv_right_injective, λ h ↦ h ▸ rfl⟩
| @[simp]
theorem Path.scoderiv_left_inj {A B : β ↝ γ} {h : β < α} :
A ↗ h = B ↗ h ↔ A = B | ConNF.Path.scoderiv_left_inj | {
"commit": "8896e416a16c39e1fe487b5fc7c78bc20c4e182b",
"date": "2024-12-03T00:00:00"
} | {
"commit": "ce890707e37ede74a2fcd66134d3f403335c5cc1",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/Levels/Path.lean | ConNF.Levels.Path | ConNF.Levels.Path.jsonl | {
"lineInFile": 337,
"tokenPositionInFile": 10251,
"theoremPositionInFile": 43
} | {
"inFilePremises": true,
"numInFilePremises": 6,
"repositoryPremises": true,
"numRepositoryPremises": 11,
"numPremises": 21
} | {
"hasProof": true,
"proof": ":=\n deriv_right_inj",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 20
} |
import ConNF.Model.Externalise
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal
namespace ConNF
variable [Params.{u}] {β γ : Λ} {hγ : (γ : TypeIndex) < β}
namespace Support
theorem not_mem_scoderiv_botDeriv (S : Support γ) (N : NearLitter) :
N ∉ (S ↗ hγ ⇘. (Path.nil ↘.))ᴺ := by
rintro ⟨i, ⟨A, N'⟩, h₁, h₂⟩
simp only [Prod.mk.injEq] at h₂
cases A
case sderiv δ A hδ _ =>
simp only [Path.deriv_sderiv] at h₂
cases A
case nil => cases h₂.1
case sderiv ζ A hζ _ =>
simp only [Path.deriv_sderiv] at h₂
cases h₂.1
variable [Level] [LtLevel β]
theorem not_mem_strong_botDeriv (S : Support γ) (N : NearLitter) :
N ∉ ((S ↗ hγ).strong ⇘. (Path.nil ↘.))ᴺ := by
rintro h
rw [strong, close_nearLitters, preStrong_nearLitters, Enumeration.mem_add_iff] at h
obtain h | h := h
· exact not_mem_scoderiv_botDeriv S N h
· rw [mem_constrainsNearLitters_nearLitters] at h
obtain ⟨B, N', hN', h⟩ := h
cases h using Relation.ReflTransGen.head_induction_on
case refl => exact not_mem_scoderiv_botDeriv S N hN'
case head x hx₁ hx₂ _ =>
obtain ⟨⟨γ, δ, ε, hδ, hε, hδε, A⟩, t, B, hB, hN, ht⟩ := hx₂
simp only at hB
cases B
case nil =>
cases hB
obtain ⟨C, N''⟩ := x
simp only at ht
cases ht.1
change _ ∈ t.supportᴺ at hN
rw [t.support_supports.2 rfl] at hN
obtain ⟨i, hN⟩ := hN
cases hN
case sderiv δ B hδ _ _ =>
cases B
case nil => cases hB
case sderiv ζ B hζ _ _ => cases hB
theorem raise_preStrong' (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hγ : (γ : TypeIndex) < β) :
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).PreStrong := by
apply hS.toPreStrong.add
constructor
intro A N hN P t hA ht
obtain ⟨A, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv hN
simp only [scoderiv_botDeriv_eq, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, interferenceSupport_nearLitters,
Enumeration.mem_add_iff, Enumeration.mem_smul, Enumeration.not_mem_empty, or_false] at hN
obtain ⟨δ, ε, ζ, hε, hζ, hεζ, B⟩ := P
dsimp only at *
cases A
case sderiv ζ' A hζ' _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_left_inj.mp at hA
cases A
case nil =>
cases hA
cases not_mem_strong_botDeriv T _ hN
case sderiv ι A hι _ _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
cases hA
haveI : LtLevel δ := ⟨A.le.trans_lt LtLevel.elim⟩
haveI : LtLevel ε := ⟨hε.trans LtLevel.elim⟩
haveI : LtLevel ζ := ⟨hζ.trans LtLevel.elim⟩
have := (T ↗ hγ).strong_strong.support_le hN ⟨δ, ε, ζ, hε, hζ, hεζ, A⟩
(ρ⁻¹ ⇘ A ↘ hε • t) rfl ?_
· simp only [Tangle.smul_support, allPermSderiv_forget, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv] at this
have := smul_le_smul this (ρᵁ ⇘ A ↘ hε)
simp only [smul_inv_smul] at this
apply le_trans this
intro B
constructor
· intro a ha
simp only [smul_derivBot, Tree.sderiv_apply, Tree.deriv_apply, Path.deriv_scoderiv,
deriv_derivBot, Enumeration.mem_smul] at ha
rw [deriv_derivBot, ← Path.deriv_scoderiv, Path.coderiv_deriv', scoderiv_botDeriv_eq,]
simp only [Path.deriv_scoderiv, add_derivBot, smul_derivBot,
BaseSupport.add_atoms, BaseSupport.smul_atoms, Enumeration.mem_add_iff,
Enumeration.mem_smul]
exact Or.inl ha
· intro N hN
simp only [smul_derivBot, Tree.sderiv_apply, Tree.deriv_apply, Path.deriv_scoderiv,
deriv_derivBot, Enumeration.mem_smul] at hN
rw [deriv_derivBot, ← Path.deriv_scoderiv, Path.coderiv_deriv', scoderiv_botDeriv_eq,]
simp only [Path.deriv_scoderiv, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, Enumeration.mem_add_iff,
Enumeration.mem_smul]
exact Or.inl hN
· rw [← smul_fuzz hε hζ hεζ, ← ht]
simp only [Path.botSderiv_coe_eq, BasePerm.smul_nearLitter_litter, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv, Tree.inv_sderivBot]
rfl
theorem raise_closed' (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hγ : (γ : TypeIndex) < β)
(hρ : ρᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim) :
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).Closed := by
constructor
intro A
constructor
intro N₁ N₂ hN₁ hN₂ a ha
simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff,
BaseSupport.add_atoms] at hN₁ hN₂ ⊢
obtain hN₁ | hN₁ := hN₁
· obtain hN₂ | hN₂ := hN₂
· exact Or.inl ((hS.closed A).interference_subset hN₁ hN₂ a ha)
· obtain ⟨B, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv hN₂
simp only [smul_add, scoderiv_botDeriv_eq, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, Enumeration.mem_add_iff,
Enumeration.mem_smul, BaseSupport.add_atoms, BaseSupport.smul_atoms] at hN₁ hN₂ ⊢
refine Or.inr (Or.inr ?_)
rw [mem_interferenceSupport_atoms]
refine ⟨(ρᵁ B)⁻¹ • N₁, ?_, (ρᵁ B)⁻¹ • N₂, ?_, ?_⟩
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
rw [← Enumeration.mem_smul, ← BaseSupport.smul_nearLitters, ← smul_derivBot, hρ]
exact Or.inl hN₁
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
simp only [interferenceSupport_nearLitters, Enumeration.not_mem_empty, or_false] at hN₂
exact Or.inr hN₂
· rw [← BasePerm.smul_interference]
exact Set.smul_mem_smul_set ha
· obtain ⟨B, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv hN₁
simp only [smul_add, scoderiv_botDeriv_eq, add_derivBot, smul_derivBot,
BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters, Enumeration.mem_add_iff,
Enumeration.mem_smul, BaseSupport.add_atoms, BaseSupport.smul_atoms] at hN₁ hN₂ ⊢
refine Or.inr (Or.inr ?_)
rw [mem_interferenceSupport_atoms]
refine ⟨(ρᵁ B)⁻¹ • N₁, ?_, (ρᵁ B)⁻¹ • N₂, ?_, ?_⟩
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
simp only [interferenceSupport_nearLitters, Enumeration.not_mem_empty, or_false] at hN₁
exact Or.inr hN₁
· simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.mem_add_iff]
simp only [interferenceSupport_nearLitters, Enumeration.not_mem_empty, or_false] at hN₂
obtain hN₂ | hN₂ := hN₂
· rw [← Enumeration.mem_smul, ← BaseSupport.smul_nearLitters, ← smul_derivBot, hρ]
exact Or.inl hN₂
· exact Or.inr hN₂
· rw [← BasePerm.smul_interference]
exact Set.smul_mem_smul_set ha
theorem raise_strong' (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hγ : (γ : TypeIndex) < β)
(hρ : ρᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim) :
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).Strong :=
⟨raise_preStrong' S hS T ρ hγ, raise_closed' S hS T ρ hγ hρ⟩
theorem convAtoms_injective_of_fixes {S : Support α} {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(A : ↑α ↝ ⊥) :
(convAtoms
(S + (ρ₁ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim) A).Injective := by
rw [Support.smul_eq_iff] at hρ₁ hρ₂
constructor
rintro a₁ a₂ a₃ ⟨i, hi₁, hi₂⟩ ⟨j, hj₁, hj₂⟩
simp only [add_derivBot, BaseSupport.add_atoms, Rel.inv_apply,
Enumeration.rel_add_iff] at hi₁ hi₂ hj₁ hj₂
obtain hi₁ | ⟨i, rfl, hi₁⟩ := hi₁
· obtain hi₂ | ⟨i', rfl, _⟩ := hi₂
swap
· have := Enumeration.lt_bound _ _ ⟨_, hi₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le i').not_lt this
cases (Enumeration.rel_coinjective _).coinjective hi₁ hi₂
obtain hj₁ | ⟨j, rfl, hj₁⟩ := hj₁
· obtain hj₂ | ⟨j', rfl, _⟩ := hj₂
· exact (Enumeration.rel_coinjective _).coinjective hj₂ hj₁
· have := Enumeration.lt_bound _ _ ⟨_, hj₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j').not_lt this
· obtain hj₂ | hj₂ := hj₂
· have := Enumeration.lt_bound _ _ ⟨_, hj₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
· simp only [add_right_inj, exists_eq_left] at hj₂
obtain ⟨B, rfl⟩ := eq_of_atom_mem_scoderiv_botDeriv ⟨j, hj₁⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_atoms,
BaseSupport.add_atoms, Enumeration.smul_rel, add_right_inj, exists_eq_left] at hj₁ hj₂
have := (Enumeration.rel_coinjective _).coinjective hj₁ hj₂
rw [← (hρ₂ B).1 a₁ ⟨_, hi₁⟩, inv_smul_smul, inv_smul_eq_iff, (hρ₁ B).1 a₁ ⟨_, hi₁⟩] at this
exact this.symm
· obtain ⟨B, rfl⟩ := eq_of_atom_mem_scoderiv_botDeriv ⟨i, hi₁⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_atoms,
BaseSupport.add_atoms, Enumeration.smul_rel, add_right_inj, exists_eq_left] at hi₁ hi₂ hj₁ hj₂
obtain hi₂ | hi₂ := hi₂
· have := Enumeration.lt_bound _ _ ⟨_, hi₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le i).not_lt this
have hi := (Enumeration.rel_coinjective _).coinjective hi₁ hi₂
suffices hj : (ρ₁ᵁ B)⁻¹ • a₂ = (ρ₂ᵁ B)⁻¹ • a₃ by
rwa [← hj, smul_left_cancel_iff] at hi
obtain hj₁ | ⟨j, rfl, hj₁⟩ := hj₁
· obtain hj₂ | ⟨j', rfl, _⟩ := hj₂
· rw [← (hρ₁ B).1 a₂ ⟨_, hj₁⟩, ← (hρ₂ B).1 a₃ ⟨_, hj₂⟩, inv_smul_smul, inv_smul_smul]
exact (Enumeration.rel_coinjective _).coinjective hj₁ hj₂
· have := Enumeration.lt_bound _ _ ⟨_, hj₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j').not_lt this
· obtain hj₂ | hj₂ := hj₂
· have := Enumeration.lt_bound _ _ ⟨_, hj₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
· simp only [add_right_inj, exists_eq_left] at hj₂
exact (Enumeration.rel_coinjective _).coinjective hj₁ hj₂
theorem atomMemRel_le_of_fixes {S : Support α} {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(A : ↑α ↝ ⊥) :
atomMemRel (S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A ≤
atomMemRel (S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A := by
rw [Support.smul_eq_iff] at hρ₁ hρ₂
rintro i j ⟨N, hN, a, haN, ha⟩
simp only [add_derivBot, BaseSupport.add_atoms, Rel.inv_apply, Enumeration.rel_add_iff,
BaseSupport.add_nearLitters] at ha hN
obtain hN | ⟨i, rfl, hi⟩ := hN
· obtain ha | ⟨j, rfl, hj⟩ := ha
· exact ⟨N, Or.inl hN, a, haN, Or.inl ha⟩
· obtain ⟨B, rfl⟩ := eq_of_atom_mem_scoderiv_botDeriv ⟨j, hj⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_atoms,
BaseSupport.add_atoms, Enumeration.smul_rel] at hj hN
refine ⟨N, Or.inl hN, ρ₂ᵁ B • (ρ₁ᵁ B)⁻¹ • a, ?_, ?_⟩
· dsimp only
rw [← (hρ₂ B).2 N ⟨_, hN⟩, BasePerm.smul_nearLitter_atoms, Set.smul_mem_smul_set_iff]
have := (hρ₁ B).2 N ⟨_, hN⟩
rw [smul_eq_iff_eq_inv_smul] at this
rwa [this, BasePerm.smul_nearLitter_atoms, Set.smul_mem_smul_set_iff]
· rw [Rel.inv_apply, add_derivBot, BaseSupport.add_atoms, Enumeration.rel_add_iff]
simp only [add_right_inj, scoderiv_botDeriv_eq, smul_derivBot, add_derivBot,
BaseSupport.smul_atoms, BaseSupport.add_atoms, Enumeration.smul_rel, inv_smul_smul,
exists_eq_left]
exact Or.inr hj
· obtain ⟨B, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv ⟨i, hi⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_atoms,
BaseSupport.add_atoms, Enumeration.smul_rel] at hi ha
obtain ha | ⟨j, rfl, hj⟩ := ha
· refine ⟨ρ₂ᵁ B • (ρ₁ᵁ B)⁻¹ • N, ?_, a, ?_, Or.inl ha⟩
· rw [add_derivBot, BaseSupport.add_nearLitters, Enumeration.rel_add_iff]
simp only [add_right_inj, scoderiv_botDeriv_eq, smul_derivBot, add_derivBot,
BaseSupport.smul_nearLitters, BaseSupport.add_nearLitters, Enumeration.smul_rel,
inv_smul_smul, exists_eq_left]
exact Or.inr hi
· dsimp only
rw [← (hρ₂ B).1 a ⟨_, ha⟩, BasePerm.smul_nearLitter_atoms, Set.smul_mem_smul_set_iff]
have := (hρ₁ B).1 a ⟨_, ha⟩
rw [smul_eq_iff_eq_inv_smul] at this
rwa [this, BasePerm.smul_nearLitter_atoms, Set.smul_mem_smul_set_iff]
· refine ⟨ρ₂ᵁ B • (ρ₁ᵁ B)⁻¹ • N, ?_, ρ₂ᵁ B • (ρ₁ᵁ B)⁻¹ • a, ?_, ?_⟩
· rw [add_derivBot, BaseSupport.add_nearLitters, Enumeration.rel_add_iff]
simp only [add_right_inj, scoderiv_botDeriv_eq, smul_derivBot, add_derivBot,
BaseSupport.smul_nearLitters, BaseSupport.add_nearLitters, Enumeration.smul_rel,
inv_smul_smul, exists_eq_left]
exact Or.inr hi
· simp only [BasePerm.smul_nearLitter_atoms, Set.smul_mem_smul_set_iff]
exact haN
· rw [Rel.inv_apply, add_derivBot, BaseSupport.add_atoms, Enumeration.rel_add_iff]
simp only [add_right_inj, scoderiv_botDeriv_eq, smul_derivBot, add_derivBot,
BaseSupport.smul_atoms, BaseSupport.add_atoms, Enumeration.smul_rel, inv_smul_smul,
exists_eq_left]
exact Or.inr hj
theorem convNearLitters_cases {S : Support α} {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
{A : α ↝ ⊥} {N₁ N₂ : NearLitter} :
convNearLitters
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A N₁ N₂ →
N₁ = N₂ ∧ N₁ ∈ (S ⇘. A)ᴺ ∨
∃ B : β ↝ ⊥, A = B ↗ LtLevel.elim ∧ (ρ₁ᵁ B)⁻¹ • N₁ = (ρ₂ᵁ B)⁻¹ • N₂ ∧
(ρ₁ᵁ B)⁻¹ • N₁ ∈ (((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport) ⇘. B)ᴺ := by
rintro ⟨i, hN₁, hN₂⟩
simp only [add_derivBot, BaseSupport.add_nearLitters, Rel.inv_apply,
Enumeration.rel_add_iff] at hN₁ hN₂
obtain hN₁ | ⟨i, rfl, hN₁⟩ := hN₁
· obtain hN₂ | ⟨i, rfl, hN₂⟩ := hN₂
swap
· have := Enumeration.lt_bound _ _ ⟨_, hN₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le i).not_lt this
exact Or.inl ⟨(Enumeration.rel_coinjective _).coinjective hN₁ hN₂, _, hN₁⟩
· obtain ⟨B, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv ⟨i, hN₁⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_nearLitters,
BaseSupport.add_nearLitters, Enumeration.smul_rel, add_right_inj, exists_eq_left] at hN₁ hN₂
obtain hN₂ | hN₂ := hN₂
· have := Enumeration.lt_bound _ _ ⟨_, hN₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le i).not_lt this
exact Or.inr ⟨B, rfl, (Enumeration.rel_coinjective _).coinjective hN₁ hN₂, _, hN₁⟩
theorem inflexible_of_inflexible_of_fixes {S : Support α} {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
{A : α ↝ ⊥} {N₁ N₂ : NearLitter} :
convNearLitters
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A N₁ N₂ →
∀ (P : InflexiblePath ↑α) (t : Tangle P.δ), A = P.A ↘ P.hε ↘. → N₁ᴸ = fuzz P.hδε t →
∃ ρ : AllPerm P.δ, N₂ᴸ = fuzz P.hδε (ρ • t) := by
rintro hN ⟨γ, δ, ε, hδ, hε, hδε, A⟩ t hA ht
haveI : LeLevel γ := ⟨A.le⟩
haveI : LtLevel δ := ⟨hδ.trans_le LeLevel.elim⟩
haveI : LtLevel ε := ⟨hε.trans_le LeLevel.elim⟩
obtain ⟨rfl, _⟩ | ⟨B, rfl, hN'⟩ := convNearLitters_cases hN
· use 1
rw [one_smul, ht]
· clear hN
cases B
case sderiv ε B hε' _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_path_injective at hA
cases B
case nil =>
simp only [Path.botSderiv_coe_eq, add_derivBot, BaseSupport.add_nearLitters,
interferenceSupport_nearLitters, Enumeration.add_empty] at hN'
cases not_mem_strong_botDeriv _ _ hN'.2
case sderiv ζ B hζ _ _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_path_injective at hA
dsimp only at hA hζ hε' B t
cases hA
use (ρ₂ * ρ₁⁻¹) ⇘ B ↘ hδ
rw [inv_smul_eq_iff] at hN'
rw [← smul_fuzz hδ hε hδε, ← ht, hN'.1]
simp only [allPermDeriv_forget, allPermForget_mul, allPermForget_inv, Tree.mul_deriv,
Tree.inv_deriv, Tree.mul_sderiv, Tree.inv_sderiv, Tree.mul_sderivBot, Tree.inv_sderivBot,
Path.botSderiv_coe_eq, BasePerm.smul_nearLitter_litter, mul_smul]
erw [inv_smul_smul, smul_inv_smul]
theorem atoms_of_inflexible_of_fixes {S : Support α} (hS : S.Strong) {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(A : α ↝ ⊥) (N₁ N₂ : NearLitter) (P : InflexiblePath ↑α) (t : Tangle P.δ) (ρ : AllPerm P.δ) :
A = P.A ↘ P.hε ↘. → N₁ᴸ = fuzz P.hδε t → N₂ᴸ = fuzz P.hδε (ρ • t) →
convNearLitters
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A N₁ N₂ →
∀ (B : P.δ ↝ ⊥), ∀ a ∈ (t.support ⇘. B)ᴬ, ∀ (i : κ),
((S + (ρ₁ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim) ⇘. (P.A ↘ P.hδ ⇘ B))ᴬ.rel i a →
((S + (ρ₂ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim) ⇘. (P.A ↘ P.hδ ⇘ B))ᴬ.rel i (ρᵁ B • a) := by
rw [Support.smul_eq_iff] at hρ₁ hρ₂
obtain ⟨γ, δ, ε, hδ, hε, hδε, B⟩ := P
haveI : LeLevel γ := ⟨B.le⟩
haveI : LtLevel δ := ⟨hδ.trans_le LeLevel.elim⟩
haveI : LtLevel ε := ⟨hε.trans_le LeLevel.elim⟩
dsimp only at t ρ ⊢
intro hA hN₁ hN₂ hN C a ha i hi
obtain ⟨rfl, hN'⟩ | ⟨A, rfl, hN₁', hN₂'⟩ := convNearLitters_cases hN
· have haS := (hS.support_le hN' ⟨γ, δ, ε, hδ, hε, hδε, _⟩ t hA hN₁ _).1 a ha
rw [hN₂] at hN₁
have hρt := congr_arg Tangle.support (fuzz_injective hN₁)
rw [Tangle.smul_support, Support.smul_eq_iff] at hρt
simp only [add_derivBot, BaseSupport.add_atoms, Enumeration.rel_add_iff] at hi ⊢
rw [(hρt C).1 a ha]
obtain hi | ⟨i, rfl, hi⟩ := hi
· exact Or.inl hi
· simp only [add_right_inj, exists_eq_left]
obtain ⟨D, hD⟩ := eq_of_atom_mem_scoderiv_botDeriv ⟨i, hi⟩
cases B using Path.recScoderiv
case nil =>
cases Path.scoderiv_index_injective hD
cases Path.scoderiv_left_inj.mp hD
simp only [hD, Path.coderiv_deriv, Path.coderiv_deriv', scoderiv_botDeriv_eq, smul_derivBot,
add_derivBot, BaseSupport.smul_atoms, BaseSupport.add_atoms, Enumeration.smul_rel] at hi ⊢
rw [deriv_derivBot, hD] at haS
rw [← (hρ₂ _).1 a haS, inv_smul_smul]
rw [← (hρ₁ _).1 a haS, inv_smul_smul] at hi
exact Or.inr hi
case scoderiv ζ B hζ' _ =>
rw [Path.coderiv_deriv, Path.coderiv_deriv'] at hD
cases Path.scoderiv_index_injective hD
rw [Path.scoderiv_left_inj] at hD
cases hD
simp only [Path.coderiv_deriv, Path.coderiv_deriv', scoderiv_botDeriv_eq, smul_derivBot,
add_derivBot, BaseSupport.smul_atoms, BaseSupport.add_atoms, Enumeration.smul_rel] at hi ⊢
rw [deriv_derivBot, Path.coderiv_deriv, Path.coderiv_deriv'] at haS
rw [← (hρ₂ _).1 a haS, inv_smul_smul]
rw [← (hρ₁ _).1 a haS, inv_smul_smul] at hi
exact Or.inr hi
· simp only [add_derivBot, BaseSupport.add_nearLitters, interferenceSupport_nearLitters,
Enumeration.add_empty] at hN₂'
cases A
case sderiv ζ A hζ' _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_path_injective at hA
cases A
case nil =>
cases hA
cases not_mem_strong_botDeriv _ _ hN₂'
case sderiv ζ A hζ _ _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_path_injective at hA
cases hA
simp only [Path.coderiv_deriv, Path.coderiv_deriv', add_derivBot, scoderiv_botDeriv_eq,
smul_derivBot, BaseSupport.add_atoms, BaseSupport.smul_atoms] at hi ⊢
have : N₂ᴸ = (ρ₂ ⇘ A)ᵁ ↘ hζ ↘. • (ρ₁⁻¹ ⇘ A)ᵁ ↘ hζ ↘. • fuzz hδε t := by
rw [inv_smul_eq_iff] at hN₁'
rw [hN₁', Path.botSderiv_coe_eq, BasePerm.smul_nearLitter_litter,
BasePerm.smul_nearLitter_litter, smul_smul, smul_eq_iff_eq_inv_smul,
mul_inv_rev, inv_inv, mul_smul, ← Tree.inv_apply, ← allPermForget_inv] at hN₁
rw [hN₁]
simp only [allPermForget_inv, Tree.inv_apply, allPermDeriv_forget, Tree.inv_deriv,
Tree.inv_sderiv, Tree.inv_sderivBot]
rfl
rw [smul_fuzz hδ hε hδε, smul_fuzz hδ hε hδε] at this
have := fuzz_injective (hN₂.symm.trans this)
rw [smul_smul] at this
rw [t.smul_atom_eq_of_mem_support this ha]
rw [Enumeration.rel_add_iff] at hi ⊢
obtain hi | ⟨i, rfl, hi⟩ := hi
· left
simp only [allPermForget_mul, allPermSderiv_forget, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv, Tree.mul_apply, Tree.sderiv_apply,
Tree.deriv_apply, Path.deriv_scoderiv, Tree.inv_apply, mul_smul]
rwa [← (hρ₁ _).1 a ⟨i, hi⟩, inv_smul_smul, (hρ₂ _).1 a ⟨i, hi⟩]
· refine Or.inr ⟨i, rfl, ?_⟩
simp only [allPermForget_mul, allPermSderiv_forget, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv, Tree.mul_apply, Tree.sderiv_apply,
Tree.deriv_apply, Path.deriv_scoderiv, Tree.inv_apply, mul_smul, Enumeration.smul_rel,
inv_smul_smul]
exact hi
theorem nearLitters_of_inflexible_of_fixes {S : Support α} (hS : S.Strong) {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(A : α ↝ ⊥) (N₁ N₂ : NearLitter) (P : InflexiblePath ↑α) (t : Tangle P.δ) (ρ : AllPerm P.δ) :
A = P.A ↘ P.hε ↘. → N₁ᴸ = fuzz P.hδε t → N₂ᴸ = fuzz P.hδε (ρ • t) →
convNearLitters
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A N₁ N₂ →
∀ (B : P.δ ↝ ⊥), ∀ N ∈ (t.support ⇘. B)ᴺ, ∀ (i : κ),
((S + (ρ₁ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim) ⇘. (P.A ↘ P.hδ ⇘ B))ᴺ.rel i N →
((S + (ρ₂ᵁ • ((T ↗ hγ).strong + (S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗
LtLevel.elim) ⇘. (P.A ↘ P.hδ ⇘ B))ᴺ.rel i (ρᵁ B • N) := by
rw [Support.smul_eq_iff] at hρ₁ hρ₂
obtain ⟨γ, δ, ε, hδ, hε, hδε, B⟩ := P
haveI : LeLevel γ := ⟨B.le⟩
haveI : LtLevel δ := ⟨hδ.trans_le LeLevel.elim⟩
haveI : LtLevel ε := ⟨hε.trans_le LeLevel.elim⟩
dsimp only at t ρ ⊢
intro hA hN₁ hN₂ hN C N₀ hN₀ i hi
obtain ⟨rfl, hN'⟩ | ⟨A, rfl, hN₁', hN₂'⟩ := convNearLitters_cases hN
· have haS := (hS.support_le hN' ⟨γ, δ, ε, hδ, hε, hδε, _⟩ t hA hN₁ _).2 N₀ hN₀
rw [hN₂] at hN₁
have hρt := congr_arg Tangle.support (fuzz_injective hN₁)
rw [Tangle.smul_support, Support.smul_eq_iff] at hρt
simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.rel_add_iff] at hi ⊢
rw [(hρt C).2 N₀ hN₀]
obtain hi | ⟨i, rfl, hi⟩ := hi
· exact Or.inl hi
· simp only [add_right_inj, exists_eq_left]
obtain ⟨D, hD⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv ⟨i, hi⟩
cases B using Path.recScoderiv
case nil =>
cases Path.scoderiv_index_injective hD
cases Path.scoderiv_left_inj.mp hD
simp only [hD, Path.coderiv_deriv, Path.coderiv_deriv', scoderiv_botDeriv_eq, smul_derivBot,
add_derivBot, BaseSupport.smul_nearLitters, BaseSupport.add_nearLitters, Enumeration.smul_rel] at hi ⊢
rw [deriv_derivBot, hD] at haS
rw [← (hρ₂ _).2 N₀ haS, inv_smul_smul]
rw [← (hρ₁ _).2 N₀ haS, inv_smul_smul] at hi
exact Or.inr hi
case scoderiv ζ B hζ' _ =>
rw [Path.coderiv_deriv, Path.coderiv_deriv'] at hD
cases Path.scoderiv_index_injective hD
rw [Path.scoderiv_left_inj] at hD
cases hD
simp only [Path.coderiv_deriv, Path.coderiv_deriv', scoderiv_botDeriv_eq, smul_derivBot,
add_derivBot, BaseSupport.smul_nearLitters, BaseSupport.add_nearLitters, Enumeration.smul_rel] at hi ⊢
rw [deriv_derivBot, Path.coderiv_deriv, Path.coderiv_deriv'] at haS
rw [← (hρ₂ _).2 N₀ haS, inv_smul_smul]
rw [← (hρ₁ _).2 N₀ haS, inv_smul_smul] at hi
exact Or.inr hi
· simp only [add_derivBot, BaseSupport.add_nearLitters, interferenceSupport_nearLitters,
Enumeration.add_empty] at hN₂'
cases A
case sderiv ζ A hζ' _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_path_injective at hA
cases A
case nil =>
cases hA
cases not_mem_strong_botDeriv _ _ hN₂'
case sderiv ζ A hζ _ _ =>
rw [← Path.coderiv_deriv] at hA
cases Path.sderiv_index_injective hA
apply Path.sderiv_path_injective at hA
cases hA
simp only [Path.coderiv_deriv, Path.coderiv_deriv', add_derivBot, scoderiv_botDeriv_eq,
smul_derivBot, BaseSupport.add_nearLitters, BaseSupport.smul_nearLitters] at hi ⊢
have : N₂ᴸ = (ρ₂ ⇘ A)ᵁ ↘ hζ ↘. • (ρ₁⁻¹ ⇘ A)ᵁ ↘ hζ ↘. • fuzz hδε t := by
rw [inv_smul_eq_iff] at hN₁'
rw [hN₁', Path.botSderiv_coe_eq, BasePerm.smul_nearLitter_litter,
BasePerm.smul_nearLitter_litter, smul_smul, smul_eq_iff_eq_inv_smul,
mul_inv_rev, inv_inv, mul_smul, ← Tree.inv_apply, ← allPermForget_inv] at hN₁
rw [hN₁]
simp only [allPermForget_inv, Tree.inv_apply, allPermDeriv_forget, Tree.inv_deriv,
Tree.inv_sderiv, Tree.inv_sderivBot]
rfl
rw [smul_fuzz hδ hε hδε, smul_fuzz hδ hε hδε] at this
have := fuzz_injective (hN₂.symm.trans this)
rw [smul_smul] at this
rw [t.smul_nearLitter_eq_of_mem_support this hN₀]
rw [Enumeration.rel_add_iff] at hi ⊢
obtain hi | ⟨i, rfl, hi⟩ := hi
· left
simp only [allPermForget_mul, allPermSderiv_forget, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv, Tree.mul_apply, Tree.sderiv_apply,
Tree.deriv_apply, Path.deriv_scoderiv, Tree.inv_apply, mul_smul]
rwa [← (hρ₁ _).2 N₀ ⟨i, hi⟩, inv_smul_smul, (hρ₂ _).2 N₀ ⟨i, hi⟩]
· refine Or.inr ⟨i, rfl, ?_⟩
simp only [allPermForget_mul, allPermSderiv_forget, allPermDeriv_forget,
allPermForget_inv, Tree.inv_deriv, Tree.inv_sderiv, Tree.mul_apply, Tree.sderiv_apply,
Tree.deriv_apply, Path.deriv_scoderiv, Tree.inv_apply, mul_smul, Enumeration.smul_rel,
inv_smul_smul]
exact hi
theorem litter_eq_of_flexible_of_fixes {S : Support α} {T : Support γ}
{ρ₁ ρ₂ : AllPerm β} {hγ : (γ : TypeIndex) < β}
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
{A : ↑α ↝ ⊥} {N₁ N₂ N₃ N₄ : NearLitter} :
convNearLitters
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A N₁ N₂ →
convNearLitters
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) A N₃ N₄ →
¬Inflexible A N₁ᴸ → ¬Inflexible A N₂ᴸ → ¬Inflexible A N₃ᴸ → ¬Inflexible A N₄ᴸ →
N₁ᴸ = N₃ᴸ → N₂ᴸ = N₄ᴸ := by
rw [Support.smul_eq_iff] at hρ₁ hρ₂
rintro ⟨i, hi₁, hi₂⟩ ⟨j, hj₁, hj₂⟩ hN₁ hN₂ hN₃ hN₄ hN₁₃
simp only [add_derivBot, BaseSupport.add_nearLitters, Rel.inv_apply,
Enumeration.rel_add_iff] at hi₁ hi₂ hj₁ hj₂
obtain hi₁ | ⟨i, rfl, hi₁⟩ := hi₁
· obtain hi₂ | ⟨i, rfl, hi₂⟩ := hi₂
swap
· have := Enumeration.lt_bound _ _ ⟨_, hi₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le i).not_lt this
cases (Enumeration.rel_coinjective _).coinjective hi₁ hi₂
obtain hj₁ | ⟨j, rfl, hj₁⟩ := hj₁
· obtain hj₂ | ⟨j, rfl, hj₂⟩ := hj₂
swap
· have := Enumeration.lt_bound _ _ ⟨_, hj₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
cases (Enumeration.rel_coinjective _).coinjective hj₁ hj₂
exact hN₁₃
· simp only [add_right_inj, exists_eq_left] at hj₂
obtain hj₂ | hj₂ := hj₂
· have := Enumeration.lt_bound _ _ ⟨_, hj₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
obtain ⟨A, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv ⟨j, hj₁⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_nearLitters,
BaseSupport.add_nearLitters, Enumeration.smul_rel] at hj₁ hj₂
have := congr_arg (·ᴸ) ((Enumeration.rel_coinjective _).coinjective hj₁ hj₂)
simp only [BasePerm.smul_nearLitter_litter] at this
rw [← hN₁₃, ← (hρ₁ A).2 N₁ ⟨i, hi₁⟩, BasePerm.smul_nearLitter_litter, inv_smul_smul] at this
have hN₁' := (hρ₂ A).2 N₁ ⟨i, hi₁⟩
rw [smul_eq_iff_eq_inv_smul] at hN₁'
rwa [hN₁', BasePerm.smul_nearLitter_litter, smul_left_cancel_iff] at this
· obtain hi₂ | hi₂ := hi₂
· have := Enumeration.lt_bound _ _ ⟨_, hi₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le i).not_lt this
simp only [add_right_inj, exists_eq_left] at hi₂
obtain ⟨A, rfl⟩ := eq_of_nearLitter_mem_scoderiv_botDeriv ⟨i, hi₁⟩
simp only [scoderiv_botDeriv_eq, smul_derivBot, add_derivBot, BaseSupport.smul_nearLitters,
BaseSupport.add_nearLitters, Enumeration.smul_rel] at hi₁ hi₂ hj₁ hj₂
have hN₁₂ := congr_arg (·ᴸ) ((Enumeration.rel_coinjective _).coinjective hi₁ hi₂)
obtain hj₁ | ⟨j, rfl, hj₁⟩ := hj₁
· obtain hj₂ | ⟨j, rfl, hj₂⟩ := hj₂
swap
· have := Enumeration.lt_bound _ _ ⟨_, hj₁⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
cases (Enumeration.rel_coinjective _).coinjective hj₁ hj₂
simp only [BasePerm.smul_nearLitter_litter] at hN₁₂
rw [hN₁₃, ← (hρ₁ A).2 N₃ ⟨j, hj₁⟩, BasePerm.smul_nearLitter_litter, inv_smul_smul,
eq_inv_smul_iff, ← BasePerm.smul_nearLitter_litter, (hρ₂ A).2 N₃ ⟨j, hj₁⟩] at hN₁₂
rw [hN₁₂]
· simp only [add_right_inj, exists_eq_left] at hj₂
obtain hj₂ | hj₂ := hj₂
· have := Enumeration.lt_bound _ _ ⟨_, hj₂⟩
simp only [add_lt_iff_neg_left] at this
cases (κ_zero_le j).not_lt this
have hN₃₄ := congr_arg (·ᴸ) ((Enumeration.rel_coinjective _).coinjective hj₁ hj₂)
simp only [BasePerm.smul_nearLitter_litter] at hN₁₂ hN₃₄
rw [hN₁₃] at hN₁₂
rwa [hN₁₂, smul_left_cancel_iff] at hN₃₄
theorem sameSpecLe_of_fixes (S : Support α) (hS : S.Strong) (T : Support γ) (ρ₁ ρ₂ : AllPerm β)
(hγ : (γ : TypeIndex) < β)
(hρ₁ : ρ₁ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim)
(hρ₂ : ρ₂ᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim) :
SameSpecLE
(S + (ρ₁ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim)
(S + (ρ₂ᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim) := by
constructor
case atoms_bound_eq => intro; rfl
case nearLitters_bound_eq => intro; rfl
case atoms_dom_subset =>
simp only [add_derivBot, BaseSupport.add_atoms, Enumeration.add_rel_dom,
Set.union_subset_iff, Set.subset_union_left, true_and]
rintro A _ ⟨i, ⟨a, ⟨A, a⟩, h₁, h₂⟩, rfl⟩
cases h₂
right
apply Set.mem_image_of_mem
refine ⟨ρ₂ᵁ A • (ρ₁ᵁ A)⁻¹ • a, ⟨A, ρ₂ᵁ A • (ρ₁ᵁ A)⁻¹ • a⟩, ?_, rfl⟩
rw [smul_atoms, Enumeration.smulPath_rel] at h₁ ⊢
simp only [inv_smul_smul]
exact h₁
case nearLitters_dom_subset =>
simp only [add_derivBot, BaseSupport.add_nearLitters, Enumeration.add_rel_dom,
Set.union_subset_iff, Set.subset_union_left, true_and]
rintro A _ ⟨i, ⟨N, ⟨A, N⟩, h₁, h₂⟩, rfl⟩
cases h₂
right
apply Set.mem_image_of_mem
refine ⟨ρ₂ᵁ A • (ρ₁ᵁ A)⁻¹ • N, ⟨A, ρ₂ᵁ A • (ρ₁ᵁ A)⁻¹ • N⟩, ?_, rfl⟩
rw [smul_nearLitters, Enumeration.smulPath_rel] at h₁ ⊢
simp only [inv_smul_smul]
exact h₁
case convAtoms_injective => exact convAtoms_injective_of_fixes hρ₁ hρ₂
case atomMemRel_le => exact atomMemRel_le_of_fixes hρ₁ hρ₂
case inflexible_of_inflexible => exact inflexible_of_inflexible_of_fixes hρ₁ hρ₂
case atoms_of_inflexible => exact atoms_of_inflexible_of_fixes hS hρ₁ hρ₂
case nearLitters_of_inflexible => exact nearLitters_of_inflexible_of_fixes hS hρ₁ hρ₂
case litter_eq_of_flexible => exact litter_eq_of_flexible_of_fixes hρ₁ hρ₂
| theorem spec_same_of_fixes (S : Support α) (hS : S.Strong) (T : Support γ) (ρ : AllPerm β)
(hρ : ρᵁ • (S ↘ LtLevel.elim : Support β) = S ↘ LtLevel.elim) :
(S + ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport) ↗ LtLevel.elim).spec =
(S + (ρᵁ • ((T ↗ hγ).strong +
(S ↘ LtLevel.elim + (T ↗ hγ).strong).interferenceSupport)) ↗ LtLevel.elim).spec | ConNF.Support.spec_same_of_fixes | {
"commit": "abf71bc79c407ceb462cc2edd2d994cda9cdef05",
"date": "2024-04-04T00:00:00"
} | {
"commit": "6709914ae7f5cd3e2bb24b413e09aa844554d234",
"date": "2024-11-30T00:00:00"
} | ConNF/ConNF/Model/RaiseStrong.lean | ConNF.Model.RaiseStrong | ConNF.Model.RaiseStrong.jsonl | {
"lineInFile": 699,
"tokenPositionInFile": 34619,
"theoremPositionInFile": 13
} | {
"inFilePremises": true,
"numInFilePremises": 1,
"repositoryPremises": true,
"numRepositoryPremises": 46,
"numPremises": 83
} | {
"hasProof": true,
"proof": ":= by\n rw [Support.spec_eq_spec_iff]\n apply sameSpec_antisymm\n · have := sameSpecLe_of_fixes S hS T 1 ρ hγ ?_ hρ\n · simp only [allPermForget_one, one_smul, smul_add] at this\n exact this\n · simp only [allPermForget_one, one_smul]\n · have := sameSpecLe_of_fixes S hS T ρ 1 hγ hρ ?_\n · simp only [allPermForget_one, one_smul, smul_add] at this\n exact this\n · simp only [allPermForget_one, one_smul]",
"proofType": "tactic",
"proofLengthLines": 10,
"proofLengthTokens": 421
} |
import ConNF.Model.Hailperin
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal ConNF.TSet
namespace ConNF
variable [Params.{u}] {α β γ δ ε ζ : Λ} (hβ : (β : TypeIndex) < α) (hγ : (γ : TypeIndex) < β)
(hδ : (δ : TypeIndex) < γ) (hε : (ε : TypeIndex) < δ) (hζ : (ζ : TypeIndex) < ε)
theorem ext (x y : TSet α) :
(∀ z : TSet β, z ∈' x ↔ z ∈' y) → x = y :=
tSet_ext' hβ x y
def inter (x y : TSet α) : TSet α :=
(TSet.exists_inter hβ x y).choose
notation:69 x:69 " ⊓[" h "] " y:69 => _root_.ConNF.inter h x y
notation:69 x:69 " ⊓' " y:69 => x ⊓[by assumption] y
@[simp]
theorem mem_inter_iff (x y : TSet α) :
∀ z : TSet β, z ∈' x ⊓' y ↔ z ∈' x ∧ z ∈' y :=
(TSet.exists_inter hβ x y).choose_spec
def compl (x : TSet α) : TSet α :=
(TSet.exists_compl hβ x).choose
notation:1024 x:1024 " ᶜ[" h "]" => _root_.ConNF.compl h x
notation:1024 x:1024 " ᶜ'" => xᶜ[by assumption]
@[simp]
theorem mem_compl_iff (x : TSet α) :
∀ z : TSet β, z ∈' xᶜ' ↔ ¬z ∈' x :=
(TSet.exists_compl hβ x).choose_spec
notation:1024 "{" x "}[" h "]" => _root_.ConNF.singleton h x
notation:1024 "{" x "}'" => {x}[by assumption]
@[simp]
theorem mem_singleton_iff (x y : TSet β) :
y ∈' {x}' ↔ y = x :=
typedMem_singleton_iff' hβ x y
notation:1024 "{" x ", " y "}[" h "]" => _root_.ConNF.TSet.up h x y
notation:1024 "{" x ", " y "}'" => {x, y}[by assumption]
@[simp]
theorem mem_up_iff (x y z : TSet β) :
z ∈' {x, y}' ↔ z = x ∨ z = y :=
TSet.mem_up_iff hβ x y z
notation:1024 "⟨" x ", " y "⟩[" h ", " h' "]" => _root_.ConNF.TSet.op h h' x y
notation:1024 "⟨" x ", " y "⟩'" => ⟨x, y⟩[by assumption, by assumption]
theorem op_def (x y : TSet γ) :
(⟨x, y⟩' : TSet α) = { {x}', {x, y}' }' :=
rfl
def singletonImage' (x : TSet β) : TSet α :=
(TSet.exists_singletonImage hβ hγ hδ hε x).choose
@[simp]
theorem singletonImage'_spec (x : TSet β) :
∀ z w,
⟨ {z}', {w}' ⟩' ∈' singletonImage' hβ hγ hδ hε x ↔ ⟨z, w⟩' ∈' x :=
(TSet.exists_singletonImage hβ hγ hδ hε x).choose_spec
def insertion2' (x : TSet γ) : TSet α :=
(TSet.exists_insertion2 hβ hγ hδ hε hζ x).choose
@[simp]
theorem insertion2'_spec (x : TSet γ) :
∀ a b c, ⟨ { {a}' }', ⟨b, c⟩' ⟩' ∈' insertion2' hβ hγ hδ hε hζ x ↔
⟨a, c⟩' ∈' x :=
(TSet.exists_insertion2 hβ hγ hδ hε hζ x).choose_spec
def insertion3' (x : TSet γ) : TSet α :=
(TSet.exists_insertion3 hβ hγ hδ hε hζ x).choose
theorem insertion3'_spec (x : TSet γ) :
∀ a b c, ⟨ { {a}' }', ⟨b, c⟩' ⟩' ∈' insertion3' hβ hγ hδ hε hζ x ↔
⟨a, b⟩' ∈' x :=
(TSet.exists_insertion3 hβ hγ hδ hε hζ x).choose_spec
def vCross (x : TSet γ) : TSet α :=
(TSet.exists_cross hβ hγ hδ x).choose
| @[simp]
theorem vCross_spec (x : TSet γ) :
∀ a, a ∈' vCross hβ hγ hδ x ↔ ∃ b c, a = ⟨b, c⟩' ∧ c ∈' x | ConNF.vCross_spec | {
"commit": "b12701769822aaf5451982e26d7b7d1c2f21b137",
"date": "2024-04-11T00:00:00"
} | {
"commit": "66f4e3291020d4198ca6ede816acae5cee584a07",
"date": "2025-01-06T00:00:00"
} | ConNF/ConNF/Model/Result.lean | ConNF.Model.Result | ConNF.Model.Result.jsonl | {
"lineInFile": 101,
"tokenPositionInFile": 2742,
"theoremPositionInFile": 25
} | {
"inFilePremises": true,
"numInFilePremises": 1,
"repositoryPremises": true,
"numRepositoryPremises": 12,
"numPremises": 27
} | {
"hasProof": true,
"proof": ":=\n (TSet.exists_cross hβ hγ hδ x).choose_spec",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 47
} |
import ConNF.Model.Result
/-!
# New file
In this file...
## Main declarations
* `ConNF.foo`: Something new.
-/
noncomputable section
universe u
open Cardinal Ordinal ConNF.TSet
namespace ConNF
variable [Params.{u}] {α β γ δ ε ζ : Λ} (hβ : (β : TypeIndex) < α) (hγ : (γ : TypeIndex) < β)
(hδ : (δ : TypeIndex) < γ) (hε : (ε : TypeIndex) < δ) (hζ : (ζ : TypeIndex) < ε)
def union (x y : TSet α) : TSet α :=
(xᶜ' ⊓' yᶜ')ᶜ'
notation:68 x:68 " ⊔[" h "] " y:68 => _root_.ConNF.union h x y
notation:68 x:68 " ⊔' " y:68 => x ⊔[by assumption] y
@[simp]
theorem mem_union_iff (x y : TSet α) :
∀ z : TSet β, z ∈' x ⊔' y ↔ z ∈' x ∨ z ∈' y := by
rw [union]
intro z
rw [mem_compl_iff, mem_inter_iff, mem_compl_iff, mem_compl_iff, or_iff_not_and_not]
def higherIndex (α : Λ) : Λ :=
(exists_gt α).choose
theorem lt_higherIndex {α : Λ} :
(α : TypeIndex) < higherIndex α :=
WithBot.coe_lt_coe.mpr (exists_gt α).choose_spec
theorem tSet_nonempty (h : ∃ β : Λ, (β : TypeIndex) < α) : Nonempty (TSet α) := by
obtain ⟨α', hα⟩ := h
constructor
apply typeLower lt_higherIndex lt_higherIndex lt_higherIndex hα
apply cardinalOne lt_higherIndex lt_higherIndex
def empty : TSet α :=
(tSet_nonempty ⟨β, hβ⟩).some ⊓' (tSet_nonempty ⟨β, hβ⟩).someᶜ'
@[simp]
theorem mem_empty_iff :
∀ x : TSet β, ¬x ∈' empty hβ := by
intro x
rw [empty, mem_inter_iff, mem_compl_iff]
exact and_not_self
def univ : TSet α :=
(empty hβ)ᶜ'
@[simp]
theorem mem_univ_iff :
∀ x : TSet β, x ∈' univ hβ := by
intro x
simp only [univ, mem_compl_iff, mem_empty_iff, not_false_eq_true]
/-- The set of all ordered pairs. -/
def orderedPairs : TSet α :=
vCross hβ hγ hδ (univ hδ)
@[simp]
theorem mem_orderedPairs_iff (x : TSet β) :
x ∈' orderedPairs hβ hγ hδ ↔ ∃ a b, x = ⟨a, b⟩' := by
simp only [orderedPairs, vCross_spec, mem_univ_iff, and_true]
def converse (x : TSet α) : TSet α :=
converse' hβ hγ hδ x ⊓' orderedPairs hβ hγ hδ
@[simp]
theorem op_mem_converse_iff (x : TSet α) :
∀ a b, ⟨a, b⟩' ∈' converse hβ hγ hδ x ↔ ⟨b, a⟩' ∈' x := by
intro a b
simp only [converse, mem_inter_iff, converse'_spec, mem_orderedPairs_iff, op_inj, exists_and_left,
exists_eq', and_true]
def cross (x y : TSet γ) : TSet α :=
converse hβ hγ hδ (vCross hβ hγ hδ x) ⊓' vCross hβ hγ hδ y
@[simp]
theorem mem_cross_iff (x y : TSet γ) :
∀ a, a ∈' cross hβ hγ hδ x y ↔ ∃ b c, a = ⟨b, c⟩' ∧ b ∈' x ∧ c ∈' y := by
intro a
rw [cross, mem_inter_iff, vCross_spec]
constructor
· rintro ⟨h₁, b, c, rfl, h₂⟩
simp only [op_mem_converse_iff, vCross_spec, op_inj] at h₁
obtain ⟨b', c', ⟨rfl, rfl⟩, h₁⟩ := h₁
exact ⟨b, c, rfl, h₁, h₂⟩
· rintro ⟨b, c, rfl, h₁, h₂⟩
simp only [op_mem_converse_iff, vCross_spec, op_inj]
exact ⟨⟨c, b, ⟨rfl, rfl⟩, h₁⟩, ⟨b, c, ⟨rfl, rfl⟩, h₂⟩⟩
def singletonImage (x : TSet β) : TSet α :=
singletonImage' hβ hγ hδ hε x ⊓' (cross hβ hγ hδ (cardinalOne hδ hε) (cardinalOne hδ hε))
@[simp]
theorem singletonImage_spec (x : TSet β) :
∀ z w,
⟨ {z}', {w}' ⟩' ∈' singletonImage hβ hγ hδ hε x ↔ ⟨z, w⟩' ∈' x := by
intro z w
rw [singletonImage, mem_inter_iff, singletonImage'_spec, and_iff_left_iff_imp]
intro hzw
rw [mem_cross_iff]
refine ⟨{z}', {w}', rfl, ?_⟩
simp only [mem_cardinalOne_iff, singleton_inj, exists_eq', and_self]
theorem exists_of_mem_singletonImage {x : TSet β} {z w : TSet δ}
(h : ⟨z, w⟩' ∈' singletonImage hβ hγ hδ hε x) :
∃ a b, z = {a}' ∧ w = {b}' := by
simp only [singletonImage, mem_inter_iff, mem_cross_iff, op_inj, mem_cardinalOne_iff] at h
obtain ⟨-, _, _, ⟨rfl, rfl⟩, ⟨a, rfl⟩, ⟨b, rfl⟩⟩ := h
exact ⟨a, b, rfl, rfl⟩
/-- Turn a model element encoding a relation into an actual relation. -/
def ExternalRel (r : TSet α) : Rel (TSet δ) (TSet δ) :=
λ x y ↦ ⟨x, y⟩' ∈' r
@[simp]
theorem externalRel_converse (r : TSet α) :
ExternalRel hβ hγ hδ (converse hβ hγ hδ r) = (ExternalRel hβ hγ hδ r).inv := by
ext
simp only [ExternalRel, op_mem_converse_iff, Rel.inv_apply]
/-- The codomain of a relation. -/
def codom (r : TSet α) : TSet γ :=
(typeLower lt_higherIndex hβ hγ hδ (singletonImage lt_higherIndex hβ hγ hδ r)ᶜ[lt_higherIndex])ᶜ'
@[simp]
theorem mem_codom_iff (r : TSet α) (x : TSet δ) :
x ∈' codom hβ hγ hδ r ↔ x ∈ (ExternalRel hβ hγ hδ r).codom := by
simp only [codom, mem_compl_iff, mem_typeLower_iff, not_forall, not_not]
constructor
· rintro ⟨y, hy⟩
obtain ⟨a, b, rfl, hb⟩ := exists_of_mem_singletonImage lt_higherIndex hβ hγ hδ hy
rw [singleton_inj] at hb
subst hb
rw [singletonImage_spec] at hy
exact ⟨a, hy⟩
· rintro ⟨a, ha⟩
use {a}'
rw [singletonImage_spec]
exact ha
/-- The domain of a relation. -/
def dom (r : TSet α) : TSet γ :=
codom hβ hγ hδ (converse hβ hγ hδ r)
@[simp]
theorem mem_dom_iff (r : TSet α) (x : TSet δ) :
x ∈' dom hβ hγ hδ r ↔ x ∈ (ExternalRel hβ hγ hδ r).dom := by
rw [dom, mem_codom_iff, externalRel_converse, Rel.inv_codom]
/-- The field of a relation. -/
def field (r : TSet α) : TSet γ :=
dom hβ hγ hδ r ⊔' codom hβ hγ hδ r
@[simp]
theorem mem_field_iff (r : TSet α) (x : TSet δ) :
x ∈' field hβ hγ hδ r ↔ x ∈ (ExternalRel hβ hγ hδ r).field := by
rw [field, mem_union_iff, mem_dom_iff, mem_codom_iff, Rel.field, Set.mem_union]
def subset : TSet α :=
subset' hβ hγ hδ hε ⊓' orderedPairs hβ hγ hδ
@[simp]
theorem subset_spec :
∀ a b, ⟨a, b⟩' ∈' subset hβ hγ hδ hε ↔ a ⊆[TSet ε] b := by
intro a b
simp only [subset, mem_inter_iff, subset'_spec, mem_orderedPairs_iff, op_inj, exists_and_left,
exists_eq', and_true]
def membership : TSet α :=
subset hβ hγ hδ hε ⊓' cross hβ hγ hδ (cardinalOne hδ hε) (univ hδ)
| @[simp]
theorem membership_spec :
∀ a b, ⟨{a}', b⟩' ∈' membership hβ hγ hδ hε ↔ a ∈' b | ConNF.membership_spec | {
"commit": "66f4e3291020d4198ca6ede816acae5cee584a07",
"date": "2025-01-06T00:00:00"
} | {
"commit": "6dd8406a01cc28b071bb26965294469664a1b592",
"date": "2025-01-07T00:00:00"
} | ConNF/ConNF/External/Basic.lean | ConNF.External.Basic | ConNF.External.Basic.jsonl | {
"lineInFile": 186,
"tokenPositionInFile": 5663,
"theoremPositionInFile": 31
} | {
"inFilePremises": true,
"numInFilePremises": 7,
"repositoryPremises": true,
"numRepositoryPremises": 26,
"numPremises": 64
} | {
"hasProof": true,
"proof": ":= by\n intro a b\n rw [membership, mem_inter_iff, subset_spec]\n simp only [mem_cross_iff, op_inj, mem_cardinalOne_iff, mem_univ_iff, and_true, exists_and_right,\n exists_and_left, exists_eq', exists_eq_left', singleton_inj]\n constructor\n · intro h\n exact h a ((typedMem_singleton_iff' hε a a).mpr rfl)\n · intro h c hc\n simp only [typedMem_singleton_iff'] at hc\n cases hc\n exact h",
"proofType": "tactic",
"proofLengthLines": 11,
"proofLengthTokens": 398
} |
import ConNF.ModelData.PathEnumeration
/-!
# Supports
In this file, we define the notion of a support.
## Main declarations
* `ConNF.BaseSupport`: The type of supports of atoms.
* `ConNF.Support`: The type of supports of objects of arbitrary type indices.
-/
universe u
open Cardinal
namespace ConNF
variable [Params.{u}]
/-!
## Base supports
-/
structure BaseSupport where
atoms : Enumeration Atom
nearLitters : Enumeration NearLitter
namespace BaseSupport
instance : SuperA BaseSupport (Enumeration Atom) where
superA := atoms
instance : SuperN BaseSupport (Enumeration NearLitter) where
superN := nearLitters
@[simp]
theorem mk_atoms {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴬ = a :=
rfl
@[simp]
theorem mk_nearLitters {a : Enumeration Atom} {N : Enumeration NearLitter} :
(BaseSupport.mk a N)ᴺ = N :=
rfl
theorem atoms_congr {S T : BaseSupport} (h : S = T) :
Sᴬ = Tᴬ :=
h ▸ rfl
theorem nearLitters_congr {S T : BaseSupport} (h : S = T) :
Sᴺ = Tᴺ :=
h ▸ rfl
@[ext]
theorem ext {S T : BaseSupport} (h₁ : Sᴬ = Tᴬ) (h₂ : Sᴺ = Tᴺ) : S = T := by
obtain ⟨SA, SN⟩ := S
obtain ⟨TA, TN⟩ := T
cases h₁
cases h₂
rfl
instance : SMul BasePerm BaseSupport where
smul π S := ⟨π • Sᴬ, π • Sᴺ⟩
@[simp]
theorem smul_atoms (π : BasePerm) (S : BaseSupport) :
(π • S)ᴬ = π • Sᴬ :=
rfl
@[simp]
theorem smul_nearLitters (π : BasePerm) (S : BaseSupport) :
(π • S)ᴺ = π • Sᴺ :=
rfl
@[simp]
theorem smul_atoms_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴬ = Sᴬ := by
rw [← smul_atoms, h]
@[simp]
theorem smul_nearLitters_eq_of_smul_eq {π : BasePerm} {S : BaseSupport}
(h : π • S = S) :
π • Sᴺ = Sᴺ := by
rw [← smul_nearLitters, h]
instance : MulAction BasePerm BaseSupport where
one_smul S := by
apply ext
· rw [smul_atoms, one_smul]
· rw [smul_nearLitters, one_smul]
mul_smul π₁ π₂ S := by
apply ext
· rw [smul_atoms, smul_atoms, smul_atoms, mul_smul]
· rw [smul_nearLitters, smul_nearLitters, smul_nearLitters, mul_smul]
theorem smul_eq_smul_iff (π₁ π₂ : BasePerm) (S : BaseSupport) :
π₁ • S = π₂ • S ↔ (∀ a ∈ Sᴬ, π₁ • a = π₂ • a) ∧ (∀ N ∈ Sᴺ, π₁ • N = π₂ • N) := by
constructor
· intro h
constructor
· rintro a ⟨i, ha⟩
have := congr_arg (·ᴬ.rel i (π₁ • a)) h
simp only [smul_atoms, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴬ.rel_coinjective.coinjective ha (this.mp ha)
rw [eq_inv_smul_iff] at this
rw [this]
· rintro N ⟨i, hN⟩
have := congr_arg (·ᴺ.rel i (π₁ • N)) h
simp only [smul_nearLitters, Enumeration.smul_rel, inv_smul_smul, eq_iff_iff] at this
have := Sᴺ.rel_coinjective.coinjective hN (this.mp hN)
rw [eq_inv_smul_iff] at this
rw [this]
· intro h
ext : 2
· rfl
· ext i a : 3
rw [smul_atoms, smul_atoms, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro ha
have := h.1 _ ⟨i, ha⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
· rfl
· ext i a : 3
rw [smul_nearLitters, smul_nearLitters, Enumeration.smul_rel, Enumeration.smul_rel]
constructor
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, ← inv_smul_eq_iff] at this
rwa [this]
· intro hN
have := h.2 _ ⟨i, hN⟩
rw [smul_inv_smul, smul_eq_iff_eq_inv_smul] at this
rwa [← this]
theorem smul_eq_iff (π : BasePerm) (S : BaseSupport) :
π • S = S ↔ (∀ a ∈ Sᴬ, π • a = a) ∧ (∀ N ∈ Sᴺ, π • N = N) := by
have := smul_eq_smul_iff π 1 S
simp only [one_smul] at this
exact this
noncomputable instance : Add BaseSupport where
add S T := ⟨Sᴬ + Tᴬ, Sᴺ + Tᴺ⟩
@[simp]
theorem add_atoms (S T : BaseSupport) :
(S + T)ᴬ = Sᴬ + Tᴬ :=
rfl
@[simp]
theorem add_nearLitters (S T : BaseSupport) :
(S + T)ᴺ = Sᴺ + Tᴺ :=
rfl
end BaseSupport
def baseSupportEquiv : BaseSupport ≃ Enumeration Atom × Enumeration NearLitter where
toFun S := (Sᴬ, Sᴺ)
invFun S := ⟨S.1, S.2⟩
left_inv _ := rfl
right_inv _ := rfl
theorem card_baseSupport : #BaseSupport = #μ := by
rw [Cardinal.eq.mpr ⟨baseSupportEquiv⟩, mk_prod, lift_id, lift_id,
card_enumeration_eq card_atom, card_enumeration_eq card_nearLitter, mul_eq_self aleph0_lt_μ.le]
/-!
## Structural supports
-/
structure Support (α : TypeIndex) where
atoms : Enumeration (α ↝ ⊥ × Atom)
nearLitters : Enumeration (α ↝ ⊥ × NearLitter)
namespace Support
variable {α β : TypeIndex}
instance : SuperA (Support α) (Enumeration (α ↝ ⊥ × Atom)) where
superA := atoms
instance : SuperN (Support α) (Enumeration (α ↝ ⊥ × NearLitter)) where
superN := nearLitters
@[simp]
theorem mk_atoms (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴬ = E :=
rfl
@[simp]
theorem mk_nearLitters (E : Enumeration (α ↝ ⊥ × Atom)) (F : Enumeration (α ↝ ⊥ × NearLitter)) :
(⟨E, F⟩ : Support α)ᴺ = F :=
rfl
instance : Derivative (Support α) (Support β) α β where
deriv S A := ⟨Sᴬ ⇘ A, Sᴺ ⇘ A⟩
instance : Coderivative (Support β) (Support α) α β where
coderiv S A := ⟨Sᴬ ⇗ A, Sᴺ ⇗ A⟩
instance : BotDerivative (Support α) BaseSupport α where
botDeriv S A := ⟨Sᴬ ⇘. A, Sᴺ ⇘. A⟩
botSderiv S := ⟨Sᴬ ↘., Sᴺ ↘.⟩
botDeriv_single S h := by dsimp only; rw [botDeriv_single, botDeriv_single]
@[simp]
theorem deriv_atoms {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴬ ⇘ A = (S ⇘ A)ᴬ :=
rfl
@[simp]
theorem deriv_nearLitters {α β : TypeIndex} (S : Support α) (A : α ↝ β) :
Sᴺ ⇘ A = (S ⇘ A)ᴺ :=
rfl
@[simp]
theorem sderiv_atoms {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴬ ↘ h = (S ↘ h)ᴬ :=
rfl
@[simp]
theorem sderiv_nearLitters {α β : TypeIndex} (S : Support α) (h : β < α) :
Sᴺ ↘ h = (S ↘ h)ᴺ :=
rfl
@[simp]
theorem coderiv_atoms {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴬ ⇗ A = (S ⇗ A)ᴬ :=
rfl
@[simp]
theorem coderiv_nearLitters {α β : TypeIndex} (S : Support β) (A : α ↝ β) :
Sᴺ ⇗ A = (S ⇗ A)ᴺ :=
rfl
@[simp]
theorem scoderiv_atoms {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴬ ↗ h = (S ↗ h)ᴬ :=
rfl
@[simp]
theorem scoderiv_nearLitters {α β : TypeIndex} (S : Support β) (h : β < α) :
Sᴺ ↗ h = (S ↗ h)ᴺ :=
rfl
@[simp]
theorem derivBot_atoms {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴬ ⇘. A = (S ⇘. A)ᴬ :=
rfl
| @[simp]
theorem derivBot_nearLitters {α : TypeIndex} (S : Support α) (A : α ↝ ⊥) :
Sᴺ ⇘. A = (S ⇘. A)ᴺ | ConNF.Support.derivBot_nearLitters | {
"commit": "39c33b4a743bea62dbcc549548b712ffd38ca65c",
"date": "2024-12-05T00:00:00"
} | {
"commit": "d9f28df240ac4df047c3af0d236aed2e437e571f",
"date": "2025-01-07T00:00:00"
} | ConNF/ConNF/ModelData/Support.lean | ConNF.ModelData.Support | ConNF.ModelData.Support.jsonl | {
"lineInFile": 258,
"tokenPositionInFile": 6529,
"theoremPositionInFile": 25
} | {
"inFilePremises": true,
"numInFilePremises": 5,
"repositoryPremises": true,
"numRepositoryPremises": 14,
"numPremises": 19
} | {
"hasProof": true,
"proof": ":=\n rfl",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 8
} |
End of preview. Expand
in Data Studio
miniCTX-v2 is a context-rich dataset for evaluation of neural theorem proving under a more realistic scenario. miniCTX-v2 is an updated version of miniCTX with new theorems extracted after a more recent cutoff date of November 28, 2024.
See our project page for more details.
Example Entry
An entry in the miniCTX dataset consists of the theorem statement, preceding file contents, and metadata information. For example, given the following theorem s_eq_pow_two
in context:
import Mathlib.Data.Real.Basic
/-!
# Square function
We define the squaring function `s : ℝ → ℝ` to be `s x := x * x`.
-/
def s (x : ℝ) : ℝ := x * x
lemma s_eq_pow_two {x : ℝ} : s x = x ^ 2 := by
rw [s, pow_two]
The problem is formatted in JSON as follows:
{
# Preceding file content
"srcContext": "import Mathlib.Data.Real.Basic\n\n/-!\n# Square function\nWe define the squaring function `s : ℝ → ℝ` to be `s x := x * x`.\n-/\n\ndef s (x : ℝ) : ℝ := x * x\n\n",
# Theorem statement
"theoremStatement": "lemma s_eq_pow_two {x : ℝ} : s x = x ^ 2",
# Fully qualified theorem name
"theoremName": "s_eq_pow_two",
# Temporal metadata
"fileCreated": {"commit":"(git commit)", "date":"(date the commit is updated)"},
"theoremCreated": {"commit":"(git commit)", "date":"(date the commit is updated)"},
# Source metadata
"file": "MyProject/Square.lean",
"module": "MyProject.Square",
"positionMetadata": {
# Line number the theorem is on
"lineInFile": 10,
# Number of tokens before the theorem
"tokenPositionInFile": 152,
# Number of premises (definitions, theorems) before the theorem
"theoremPositionInFile": 1
},
# Dependency metadata
"dependencyMetadata": {
# Number of definitions or lemmas defined in this file that the theorem uses
"inFilePremises": true,
"numInFilePremises": 1,
# Number of definitions or lemmas defined in this repository that the theorem uses (including in-file ones)
"repositoryPremises": true
"numRepositoryPremises": 1,
# Number of total premises (in file, repository, or otherwise)
"numPremises": 2,
},
# Proof metadata
"proofMetadata": {
"hasProof": true,
"proof": "by\n rw [s, pow_two]",
"proofType": "tactic",
"proofLengthLines": 2,
"proofLengthTokens": 20
}
}
Description of Each Entry
- srcContext: The context of the source file preceding the theorem, including imports and relevant definitions. This provides necessary background to understand the theorem.
- theoremStatement: The statement of the theorem being proved.
- theoremName: The name of the theorem.
- fileCreated: The git commit hash indicating when the file was created.
- theoremCreated: The git commit hash indicating when the theorem was added.
- file: The name of the file containing the theorem.
- positionMetadata:
- lineInFile: The line number in the file where the theorem is located.
- tokenPositionInFile: The number of tokens in the file before the theorem starts.
- theoremPositionInFile: The number of premises (definitions, theorems) before the theorem in the file.
- dependencyMetadata:
- inFilePremises: Indicates whether the theorem uses definitions or lemmas defined in the same file.
- numInFilePremises: The number of definitions or lemmas from the same file that the theorem relies on.
- repositoryPremises: Indicates whether the theorem uses definitions or lemmas defined in another file within the same repository.
- numRepositoryPremises: The total number of definitions or lemmas from the repository (including the current file) that the theorem depends on.
- numPremises: The total number of premises the theorem depends on, regardless of whether they are from the same file, the repository, or external sources.
- proofMetadata:
- hasProof: Indicates whether the theorem has a proof.
- proof: The proof of the theorem.
- proofType: The type of proof, term proof or tactic proof.
- proofLengthLines: The length of the proof in lines.
- proofLengthTokens: The length of the proof in tokens.
In addition to individual entries, we also provide the link and git commit version of each split for evaluation:
- Carleson: https://github.com/fpvandoorn/carleson, commit a5d265f109105809de4aaff16776b7c16b1c0bd5
- ConNF: https://github.com/leanprover-community/con-nf, commit 51c38ad244870b8b1f40b8272b281678397dfa4f
- FLT: https://github.com/ImperialCollegeLondon/FLT, commit 4a97c893071433d0d39cbf5261d0877f864c2189
- Foundation: https://github.com/FormalizedFormalLogic/Foundation, commit 54324e6e009f0d0a288897312d3feb1c0165ad19
- HepLean: https://github.com/HEPLean/PhysLean, commit fe082d93c2775beee6634b24b34c8482a02ba8a8
- Mathlib: https://github.com/leanprover-community/mathlib4, tag v4.16.0
- Seymour: https://github.com/Ivan-Sergeyev/seymour, commit 27c0384977032b693daca8c4fcfc5cc274e1f2d6
miniCTX-v2 uses Lean version v4.16.0.
Citation
Please cite:
@article{hu2024minictx,
title={miniCTX: Neural Theorem Proving with (Long-) Contexts},
author={Hu, Jiewen and Zhu, Thomas and Welleck, Sean},
journal={arXiv preprint arXiv:2408.03350},
year={2024}
}
- Downloads last month
- 32