Theorem: Profinite.NobelingProof.GoodProducts.injective
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: intro ⟨a, ha⟩ ⟨b, hb⟩ h
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
⊢ Function.Injective (eval C)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : eval C ⟨a, ha⟩ = eval C ⟨b, hb⟩
⊢ ⟨a, ha⟩ = ⟨b, hb⟩

tactic: dsimp [eval] at h
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : eval C ⟨a, ha⟩ = eval C ⟨b, hb⟩
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩

tactic: rcases lt_trichotomy a b with (h'|rfl|h')
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
state_after: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩

case inr.inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha hb : Products.isGood C a
h : Products.eval C a = Products.eval C a
⊢ ⟨a, ha⟩ = ⟨a, hb⟩

case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ ⟨a, ha⟩ = ⟨b, hb⟩

tactic: exfalso
state_before: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
state_after: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ False

tactic: apply hb
state_before: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ False
state_after: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ Products.eval C b ∈ Submodule.span ℤ (Products.eval C '' {m | m < b})

tactic: rw [← h]
state_before: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ Products.eval C b ∈ Submodule.span ℤ (Products.eval C '' {m | m < b})
state_after: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ Products.eval C a ∈ Submodule.span ℤ (Products.eval C '' {m | m < b})

tactic: exact Submodule.subset_span ⟨a, h', rfl⟩
state_before: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ Products.eval C a ∈ Submodule.span ℤ (Products.eval C '' {m | m < b})
state_after: no goals

tactic: rfl
state_before: case inr.inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha hb : Products.isGood C a
h : Products.eval C a = Products.eval C a
⊢ ⟨a, ha⟩ = ⟨a, hb⟩
state_after: no goals

tactic: exfalso
state_before: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
state_after: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ False

tactic: apply ha
state_before: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ False
state_after: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ Products.eval C a ∈ Submodule.span ℤ (Products.eval C '' {m | m < a})

tactic: rw [h]
state_before: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ Products.eval C a ∈ Submodule.span ℤ (Products.eval C '' {m | m < a})
state_after: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ Products.eval C b ∈ Submodule.span ℤ (Products.eval C '' {m | m < a})

tactic: exact Submodule.subset_span ⟨b, ⟨h',rfl⟩⟩
state_before: case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ Products.eval C b ∈ Submodule.span ℤ (Products.eval C '' {m | m < a})
state_after: no goals