ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Group.mem_conjugatesOfSet_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s : Set G
x : G
⊢ x ∈ conjugatesOfSet s ↔ ∃ a ∈ s, IsConj a x
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s : Set G
x : G
⊢ (∃ i, ∃ (_ : i ∈ s), x ∈ conjugatesOf i) ↔ ∃ a ∈ s, IsConj a x
tactic: erw [Set.mem_iUnion₂]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s : Set G
x : G
⊢ (∃ i, ∃ (_ : i ∈ s), x ∈ conjugatesOf i) ↔ ∃ a ∈ s, IsConj a x
state_after: no goals
tactic: simp only [conjugatesOf, isConj_iff, Set.mem_setOf_eq, exists_prop]
Theorem: SimpleGraph.Iso.connectedComponentEquiv_trans
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
⊢ connectedComponentEquiv (RelIso.trans φ φ') = φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv
state_after: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
x✝ : G.ConnectedComponent
a✝ : V
⊢ (connectedComponentEquiv (RelIso.trans φ φ')) (Quot.mk G.Reachable a✝) =
    (φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv) (Quot.mk G.Reachable a✝)
tactic: ext ⟨_⟩
state_before: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
x✝ : G.ConnectedComponent
a✝ : V
⊢ (connectedComponentEquiv (RelIso.trans φ φ')) (Quot.mk G.Reachable a✝) =
    (φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv) (Quot.mk G.Reachable a✝)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.FunctorToTypes.binaryProductEquiv_symm_apply
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : (F ⨯ G).obj a
⊢ (fun z => prodMk z.1 z.2)
      ((fun z => (((binaryProductIso F G).hom.app a z).1, ((binaryProductIso F G).hom.app a z).2)) x✝) =
    x✝
state_after: no goals
tactic: simp [prodMk]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : F.obj a × G.obj a
⊢ (fun z => (((binaryProductIso F G).hom.app a z).1, ((binaryProductIso F G).hom.app a z).2))
      ((fun z => prodMk z.1 z.2) x✝) =
    x✝
state_after: no goals
tactic: simp [prodMk]
Theorem: Module.End.mem_maxGenEigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

Proof steps:
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
m : M
⊢ m ∈ f.maxGenEigenspace μ ↔ ∃ k, ((f - μ • 1) ^ k) m = 0
state_after: no goals
tactic: simp only [maxGenEigenspace, ← mem_genEigenspace, Submodule.mem_iSup_of_chain]
Theorem: ProbabilityTheory.Kernel.measurableSet_absolutelyContinuous
File: Mathlib/Probability/Kernel/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
⊢ MeasurableSet {a | κ a ≪ η a}
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
⊢ MeasurableSet {a | (κ a) (κ.mutuallySingularSetSlice η a) = 0}
tactic: simp_rw [← singularPart_eq_zero_iff_absolutelyContinuous,
    singularPart_eq_zero_iff_measure_eq_zero]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
⊢ MeasurableSet {a | (κ a) (κ.mutuallySingularSetSlice η a) = 0}
state_after: no goals
tactic: exact measurable_kernel_prod_mk_left (measurableSet_mutuallySingularSet κ η)
    (measurableSet_singleton 0)
Theorem: Matrix.isSymm_compl
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

Proof steps:
state_before: V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
h : A.IsSymm
⊢ A.compl.IsSymm
state_after: case a
V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
h : A.IsSymm
i✝ j✝ : V
⊢ A.complᵀ i✝ j✝ = A.compl i✝ j✝
tactic: ext
state_before: case a
V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
h : A.IsSymm
i✝ j✝ : V
⊢ A.complᵀ i✝ j✝ = A.compl i✝ j✝
state_after: no goals
tactic: simp [compl, h.apply, eq_comm]
Theorem: Finset.preimage_mul_right_singleton
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Finset α
a b : α
⊢ {b}.preimage (fun x => x * a) ⋯ = {b * a⁻¹}
state_after: no goals
tactic: classical rw [← image_mul_right', image_singleton]
Theorem: Turing.TM2to1.step_run
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S =
    TM2.stepAux q (stVar v (S k) (StAct.peek f)) (update S k (stWrite v (S k) (StAct.peek f)))
state_after: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S =
    TM2.stepAux q (stVar v (S k) (StAct.peek f))
      (update S k
        (match StAct.peek f with
        | StAct.push f => f v :: S k
        | StAct.peek a => S k
        | StAct.pop a => (S k).tail))
tactic: unfold stWrite
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S =
    TM2.stepAux q (stVar v (S k) (StAct.peek f))
      (update S k
        (match StAct.peek f with
        | StAct.push f => f v :: S k
        | StAct.peek a => S k
        | StAct.pop a => (S k).tail))
state_after: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S = TM2.stepAux q (stVar v (S k) (StAct.peek f)) S
tactic: rw [Function.update_eq_self]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S = TM2.stepAux q (stVar v (S k) (StAct.peek f)) S
state_after: no goals
tactic: rfl
Theorem: FintypeCat.equivEquivIso_apply_inv
File: Mathlib/CategoryTheory/FintypeCat.lean

Proof steps:
state_before: A B : FintypeCat
⊢ Function.LeftInverse (fun i => { toFun := i.hom, invFun := i.inv, left_inv := ⋯, right_inv := ⋯ }) fun e =>
    { hom := ⇑e, inv := ⇑e.symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }
state_after: no goals
tactic: aesop_cat
state_before: A B : FintypeCat
⊢ Function.RightInverse (fun i => { toFun := i.hom, invFun := i.inv, left_inv := ⋯, right_inv := ⋯ }) fun e =>
    { hom := ⇑e, inv := ⇑e.symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }
state_after: no goals
tactic: aesop_cat
Theorem: orderOf_abs_ne_one
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
⊢ orderOf x = 0
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
⊢ ∀ (n : ℕ), 0 < n → x ^ n ≠ 1
tactic: rw [orderOf_eq_zero_iff']
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
⊢ ∀ (n : ℕ), 0 < n → x ^ n ≠ 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
n : ℕ
hn : 0 < n
hx : x ^ n = 1
⊢ False
tactic: intro n hn hx
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
n : ℕ
hn : 0 < n
hx : x ^ n = 1
⊢ False
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
n : ℕ
hn : 0 < n
hx : |x| ^ n = 1
⊢ False
tactic: replace hx : |x| ^ n = 1 := by simpa only [abs_one, abs_pow] using congr_arg abs hx
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h : |x| ≠ 1
n : ℕ
hn : 0 < n
hx : |x| ^ n = 1
⊢ False
state_after: case inl
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h✝ : |x| ≠ 1
n : ℕ
hn : 0 < n
hx : |x| ^ n = 1
h : |x| < 1
⊢ False

case inr
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LinearOrderedRing G
a x : G
h✝ : |x| ≠ 1
n : ℕ
hn : 0 < n
hx : |x| ^ n = 1
h : 1 < |x|
⊢ False
tactic: cases' h.lt_or_lt with h h
Theorem: WittVector.map_frobeniusPoly.key₂
File: Mathlib/RingTheory/WittVector/Frobenius.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
⊢ j - v p ⟨j + 1, ⋯⟩ + n = i + j + (n - i - v p ⟨j + 1, ⋯⟩)
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
⊢ j - m + n = i + j + (n - i - m)
tactic: generalize h : v p ⟨j + 1, j.succ_pos⟩ = m
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
⊢ j - m + n = i + j + (n - i - m)
state_after: case intro
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
h₁ : m ≤ n - i
h₂ : m ≤ j
⊢ j - m + n = i + j + (n - i - m)

p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
⊢ m ≤ n - i ∧ m ≤ j
tactic: rsuffices ⟨h₁, h₂⟩ : m ≤ n - i ∧ m ≤ j
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
⊢ m ≤ n - i ∧ m ≤ j
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
hle : p ^ m ≤ j + 1
⊢ m ≤ n - i ∧ m ≤ j
tactic: have hle : p ^ m ≤ j + 1 := h ▸ Nat.le_of_dvd j.succ_pos (multiplicity.pow_multiplicity_dvd _)
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n i j : ℕ
hi : i ≤ n
hj : j < p ^ (n - i)
m : ℕ
h : v p ⟨j + 1, ⋯⟩ = m
hle : p ^ m ≤ j + 1
⊢ m ≤ n - i ∧ m ≤ j
state_after: no goals
tactic: exact ⟨(pow_le_pow_iff_right hp.1.one_lt).1 (hle.trans hj),
     Nat.le_of_lt_succ ((Nat.lt_pow_self hp.1.one_lt m).trans_le hle)⟩
Theorem: List.kreplace_nodupKeys
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
⊢ (kreplace a b l).NodupKeys ↔ l.NodupKeys
state_after: no goals
tactic: simp [NodupKeys, keys_kreplace]
Theorem: Set.Definable.union
File: Mathlib/ModelTheory/Definability.lean

Proof steps:
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
hf : A.Definable L f
hg : A.Definable L g
⊢ A.Definable L (f ∪ g)
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
hg : A.Definable L g
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
⊢ A.Definable L (f ∪ g)
tactic: rcases hf with ⟨φ, hφ⟩
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
hg : A.Definable L g
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
⊢ A.Definable L (f ∪ g)
state_after: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
θ : L[[↑A]].Formula α
hθ : g = setOf θ.Realize
⊢ A.Definable L (f ∪ g)
tactic: rcases hg with ⟨θ, hθ⟩
state_before: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
θ : L[[↑A]].Formula α
hθ : g = setOf θ.Realize
⊢ A.Definable L (f ∪ g)
state_after: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
θ : L[[↑A]].Formula α
hθ : g = setOf θ.Realize
⊢ f ∪ g = setOf (φ ⊔ θ).Realize
tactic: refine ⟨φ ⊔ θ, ?_⟩
state_before: case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
θ : L[[↑A]].Formula α
hθ : g = setOf θ.Realize
⊢ f ∪ g = setOf (φ ⊔ θ).Realize
state_after: case intro.intro.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
θ : L[[↑A]].Formula α
hθ : g = setOf θ.Realize
x✝ : α → M
⊢ x✝ ∈ f ∪ g ↔ x✝ ∈ setOf (φ ⊔ θ).Realize
tactic: ext
state_before: case intro.intro.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s f g : Set (α → M)
φ : L[[↑A]].Formula α
hφ : f = setOf φ.Realize
θ : L[[↑A]].Formula α
hθ : g = setOf θ.Realize
x✝ : α → M
⊢ x✝ ∈ f ∪ g ↔ x✝ ∈ setOf (φ ⊔ θ).Realize
state_after: no goals
tactic: rw [hφ, hθ, mem_setOf_eq, Formula.realize_sup, mem_union, mem_setOf_eq, mem_setOf_eq]
Theorem: Polynomial.natDegree_of_subsingleton
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Subsingleton R
⊢ p.natDegree = 0
state_after: no goals
tactic: rw [Subsingleton.elim p 0, natDegree_zero]
Theorem: FirstOrder.Language.BoundedFormula.sup_semanticallyEquivalent_not_inf_not
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (φ ⊔ ψ ⇔ ∼(∼φ ⊓ ∼ψ)).Realize v xs
state_after: no goals
tactic: simp [imp_iff_not_or]
Theorem: zorn_nonempty_preorder₀
File: Mathlib/Order/Zorn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
s : Set α
ih : ∀ c ⊆ s, IsChain (fun x x_1 => x ≤ x_1) c → ∀ y ∈ c, ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub
x : α
hxs : x ∈ s
⊢ ∃ m ∈ s, x ≤ m ∧ ∀ z ∈ s, m ≤ z → z ≤ m
state_after: case refine_2
α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
inst✝ : Preorder α
s : Set α
ih : ∀ c ⊆ s, IsChain (fun x x_1 => x ≤ x_1) c → ∀ y ∈ c, ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub
x : α
hxs : x ∈ s
H : ∃ m ∈ {y | y ∈ s ∧ x ≤ y}, ∀ z ∈ {y | y ∈ s ∧ x ≤ y}, m ≤ z → z ≤ m
⊢ ∃ m ∈ s, x ≤ m ∧ ∀ z ∈ s, m ≤ z → z ≤ m

case refine_1
α : Type u_1
β : Type u_2
r : α → α → Prop
c✝ : Set α
inst✝ : Preorder α
s : Set α
ih : ∀ c ⊆ s, IsChain (fun x x_1 => x ≤ x_1) c → ∀ y ∈ c, ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub
x : α
hxs : x ∈ s
c : Set α
hcs : c ⊆ {y | y ∈ s ∧ x ≤ y}
hc : IsChain (fun x x_1 => x ≤ x_1) c
⊢ ∃ ub ∈ {y | y ∈ s ∧ x ≤ y}, ∀ z ∈ c, z ≤ ub
tactic: have H := zorn_preorder₀ ({ y ∈ s | x ≤ y }) fun c hcs hc => ?_
Theorem: Fin.snoc_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ (last n)
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.castSucc
i : Fin n
y : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
p : Fin 0 → α
x : α
⊢ snoc p x = fun x_1 => x
state_after: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ (last n)
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
p : Fin 0 → α
x : α
y : Fin (0 + 1)
⊢ snoc p x y = x
tactic: ext y
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ (last n)
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
p : Fin 0 → α
x : α
y : Fin (0 + 1)
⊢ snoc p x y = x
state_after: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ (last n)
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
p : Fin 0 → α
x : α
y : Fin (0 + 1)
this : Subsingleton (Fin (0 + 1))
⊢ snoc p x y = x
tactic: have : Subsingleton (Fin (0 + 1)) := Fin.subsingleton_one
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ (last n)
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
p : Fin 0 → α
x : α
y : Fin (0 + 1)
this : Subsingleton (Fin (0 + 1))
⊢ snoc p x y = x
state_after: no goals
tactic: simp only [Subsingleton.elim y (Fin.last 0), snoc_last]
Theorem: Int.card_Ioo_of_lt
File: Mathlib/Data/Int/Interval.lean

Proof steps:
state_before: a b : ℤ
h : a < b
⊢ ↑(Ioo a b).card = b - a - 1
state_after: no goals
tactic: rw [card_Ioo, sub_sub, toNat_sub_of_le h]
Theorem: Fin.one_mul'
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
k : Fin n
⊢ 1 * k = k
state_after: no goals
tactic: rw [Fin.mul_comm, Fin.mul_one']
Theorem: Ordinal.nfp_add_eq_mul_omega
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ nfp (fun x => a + x) b = a * ω
state_after: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ a * ω ≤ nfp (fun x => a + x) b

a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ a + a * ω ≤ a * ω
tactic: apply le_antisymm (nfp_le_fp (add_isNormal a).monotone hba _)
Theorem: CategoryTheory.ShortComplex.toCycles_comp_homologyπ
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ S.toCycles ≫ S.homologyπ = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ S.toCycles ≫ S.leftHomologyπ ≫ S.leftHomologyIso.hom = 0
tactic: dsimp only [homologyπ]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ S.toCycles ≫ S.leftHomologyπ ≫ S.leftHomologyIso.hom = 0
state_after: no goals
tactic: simp only [toCycles_comp_leftHomologyπ_assoc, zero_comp]
Theorem: Fintype.prod_ite_eq_ite_exists
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α✝
a✝ : α✝
f g : α✝ → β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝³ : Fintype ι
inst✝² : Fintype κ
inst✝¹ : CommMonoid α
p : ι → Prop
inst✝ : DecidablePred p
h : ∀ (i j : ι), p i → p j → i = j
a : α
⊢ (∏ i : ι, if p i then a else 1) = if ∃ i, p i then a else 1
state_after: no goals
tactic: simp [prod_ite_one univ p (by simpa using h)]
Theorem: Substring.Valid.data_drop
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: x✝¹ : Substring
h✝ : x✝¹.Valid
x✝ : Nat
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝¹
⊢ (x✝¹.drop x✝).toString.data = List.drop x✝ x✝¹.toString.data
state_after: no goals
tactic: simp [(h.drop _).toString, h.toString]
Theorem: irreducible_mul_iff
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a b : α
⊢ Irreducible (a * b) ↔ Irreducible a ∧ IsUnit b ∨ Irreducible b ∧ IsUnit a
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a b : α
⊢ Irreducible (a * b) → Irreducible a ∧ IsUnit b ∨ Irreducible b ∧ IsUnit a

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a b : α
⊢ Irreducible a ∧ IsUnit b ∨ Irreducible b ∧ IsUnit a → Irreducible (a * b)
tactic: constructor
Theorem: Submodule.map_dualCoannihilator_linearEquiv_flip
File: Mathlib/LinearAlgebra/PerfectPairing.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
⊢ map e.flip p.dualCoannihilator = (map e.symm p).dualAnnihilator
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
this : IsReflexive R N
⊢ map e.flip p.dualCoannihilator = (map e.symm p).dualAnnihilator
tactic: have : IsReflexive R N := e.isReflexive_of_equiv_dual_of_isReflexive
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
this : IsReflexive R N
⊢ map e.flip p.dualCoannihilator = (map e.symm p).dualAnnihilator
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
this : IsReflexive R N
⊢ map e.flip.symm (map e.symm p).dualAnnihilator = map e.flip.symm (map e.flip p.dualCoannihilator)
tactic: suffices (p.map e.symm).dualAnnihilator.map e.flip.symm =
      (p.dualCoannihilator.map e.flip).map e.flip.symm by
    exact (Submodule.map_injective_of_injective e.flip.symm.injective this).symm
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
this : IsReflexive R N
⊢ map e.flip.symm (map e.symm p).dualAnnihilator = map e.flip.symm (map e.flip p.dualCoannihilator)
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
this : IsReflexive R N
⊢ (map (↑e ∘ₗ ↑e.symm) p).dualCoannihilator = map (↑e.flip.symm ∘ₗ ↑e.flip) p.dualCoannihilator
tactic: erw [← dualCoannihilator_map_linearEquiv_flip, flip_flip, ← map_comp, ← map_comp]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsReflexive R M
e : N ≃ₗ[R] Dual R M
p : Submodule R (Dual R M)
this : IsReflexive R N
⊢ (map (↑e ∘ₗ ↑e.symm) p).dualCoannihilator = map (↑e.flip.symm ∘ₗ ↑e.flip) p.dualCoannihilator
state_after: no goals
tactic: simp [-coe_toLinearMap_flip]