ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearEquiv.toSpanNonzeroSingleton_apply
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
t : R
⊢ (toSpanNonzeroSingleton R M x h) t = ⟨t • x, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: Part.inv_mem_inv
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Inv α
a : Part α
ma : α
ha : ma ∈ a
⊢ ma⁻¹ ∈ a⁻¹
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Inv α
a : Part α
ma : α
ha : ma ∈ a
⊢ ∃ a_1 ∈ a, a_1⁻¹ = ma⁻¹
tactic: simp [inv_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Inv α
a : Part α
ma : α
ha : ma ∈ a
⊢ ∃ a_1 ∈ a, a_1⁻¹ = ma⁻¹
state_after: no goals
tactic: aesop
Theorem: Equiv.Perm.disjoint_conj
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
f g h✝ h : Perm α
x✝ : α
⊢ (h * f * h⁻¹) x✝ = x✝ ∨ (h * g * h⁻¹) x✝ = x✝ ↔ f (h⁻¹ x✝) = h⁻¹ x✝ ∨ g (h⁻¹ x✝) = h⁻¹ x✝
state_after: no goals
tactic: simp only [mul_apply, eq_inv_iff_eq]
Theorem: orthogonalProjection_eq_zero_iff
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
⊢ (orthogonalProjection K) v = 0 ↔ v ∈ Kᗮ
state_after: case refine_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
h : (orthogonalProjection K) v = 0
⊢ v ∈ Kᗮ

case refine_2
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
h : v ∈ Kᗮ
⊢ v - ↑0 ∈ Kᗮ
tactic: refine ⟨fun h ↦ ?_, fun h ↦ Subtype.eq <| eq_orthogonalProjection_of_mem_orthogonal
    (zero_mem _) ?_⟩
Theorem: Pi.single_comm
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
inst✝⁴ : DecidableEq I
inst✝³ : (i : I) → One (f i)
inst✝² : (i : I) → One (g i)
inst✝¹ : (i : I) → One (h i)
inst✝ : One β
i : I
x : β
i' : I
⊢ mulSingle i x i' = mulSingle i' x i
state_after: no goals
tactic: simp [mulSingle_apply, eq_comm]
Theorem: FractionalIdeal.dual_inv
File: Mathlib/RingTheory/DedekindDomain/Different.lean

Proof steps:
state_before: A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁸ : CommRing A
inst✝¹⁷ : Field K
inst✝¹⁶ : CommRing B
inst✝¹⁵ : Field L
inst✝¹⁴ : Algebra A K
inst✝¹³ : Algebra B L
inst✝¹² : Algebra A B
inst✝¹¹ : Algebra K L
inst✝¹⁰ : Algebra A L
inst✝⁹ : IsScalarTower A K L
inst✝⁸ : IsScalarTower A B L
inst✝⁷ : IsDomain A
inst✝⁶ : IsFractionRing A K
inst✝⁵ : IsIntegralClosure B A L
inst✝⁴ : IsFractionRing B L
inst✝³ : FiniteDimensional K L
inst✝² : Algebra.IsSeparable K L
inst✝¹ : IsIntegrallyClosed A
inst✝ : IsDedekindDomain B
I J : FractionalIdeal B⁰ L
hI : I ≠ 0
hJ : J ≠ 0
⊢ dual A K I⁻¹ = dual A K 1 * I
state_after: no goals
tactic: rw [dual_eq_mul_inv, inv_inv]
Theorem: CategoryTheory.regularTopology.exists_effectiveEpi_iff_mem_induced
File: Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
F : C ⥤ D
inst✝⁵ : F.PreservesEffectiveEpis
inst✝⁴ : F.ReflectsEffectiveEpis
inst✝³ : F.Full
inst✝² : F.Faithful
inst✝¹ : F.EffectivelyEnough
inst✝ : Preregular D
X : C
S : Sieve X
⊢ (∃ Y π, EffectiveEpi π ∧ S.arrows π) ↔ S ∈ (F.inducedTopology (regularTopology D)).sieves X
state_after: case refine_1
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
F : C ⥤ D
inst✝⁵ : F.PreservesEffectiveEpis
inst✝⁴ : F.ReflectsEffectiveEpis
inst✝³ : F.Full
inst✝² : F.Faithful
inst✝¹ : F.EffectivelyEnough
inst✝ : Preregular D
X : C
S : Sieve X
x✝ : ∃ Y π, EffectiveEpi π ∧ S.arrows π
Y : C
π : Y ⟶ X
H₁ : EffectiveEpi π
H₂ : S.arrows π
⊢ S ∈ (F.inducedTopology (regularTopology D)).sieves X

case refine_2
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
F : C ⥤ D
inst✝⁵ : F.PreservesEffectiveEpis
inst✝⁴ : F.ReflectsEffectiveEpis
inst✝³ : F.Full
inst✝² : F.Faithful
inst✝¹ : F.EffectivelyEnough
inst✝ : Preregular D
X : C
S : Sieve X
hS : S ∈ (F.inducedTopology (regularTopology D)).sieves X
⊢ ∃ Y π, EffectiveEpi π ∧ S.arrows π
tactic: refine ⟨fun ⟨Y, π, ⟨H₁, H₂⟩⟩ ↦ ?_, fun hS ↦ ?_⟩
Theorem: BoxIntegral.Box.iUnion_coe_splitCenterBox
File: Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean

Proof steps:
state_before: ι : Type u_1
I✝ J I : Box ι
⊢ ⋃ s, ↑(I.splitCenterBox s) = ↑I
state_after: case h
ι : Type u_1
I✝ J I : Box ι
x : ι → ℝ
⊢ x ∈ ⋃ s, ↑(I.splitCenterBox s) ↔ x ∈ ↑I
tactic: ext x
state_before: case h
ι : Type u_1
I✝ J I : Box ι
x : ι → ℝ
⊢ x ∈ ⋃ s, ↑(I.splitCenterBox s) ↔ x ∈ ↑I
state_after: no goals
tactic: simp
Theorem: ContDiffBump.normed_sub
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : HasContDiffBump E
inst✝ : MeasurableSpace E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
μ : Measure E
x : E
⊢ f.normed μ (c - x) = f.normed μ (c + x)
state_after: no goals
tactic: simp_rw [f.normed_def, f.sub]
Theorem: Real.le_sSup_iff
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: s : Set ℝ
h : BddAbove s
h' : s.Nonempty
a : ℝ
⊢ a ≤ sSup s ↔ ∀ ε < 0, ∃ x ∈ s, a + ε < x
state_after: s : Set ℝ
h : BddAbove s
h' : s.Nonempty
a : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → a < sSup s + ε) ↔ ∀ ε < 0, ∃ x ∈ s, a + ε < x
tactic: rw [le_iff_forall_pos_lt_add]
state_before: s : Set ℝ
h : BddAbove s
h' : s.Nonempty
a : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → a < sSup s + ε) ↔ ∀ ε < 0, ∃ x ∈ s, a + ε < x
state_after: case refine_1
s : Set ℝ
h : BddAbove s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → a < sSup s + ε
ε : ℝ
ε_neg : ε < 0
⊢ ∃ x ∈ s, a + ε < x

case refine_2
s : Set ℝ
h : BddAbove s
h' : s.Nonempty
a : ℝ
H : ∀ ε < 0, ∃ x ∈ s, a + ε < x
ε : ℝ
ε_pos : 0 < ε
⊢ a < sSup s + ε
tactic: refine ⟨fun H ε ε_neg => ?_, fun H ε ε_pos => ?_⟩
Theorem: Module.End.injOn_genEigenspace
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
inst✝ : NoZeroSMulDivisors R M
f : End R M
⊢ InjOn (fun x => ⨆ k, (f.genEigenspace x) k) {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
state_after: 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
inst✝ : NoZeroSMulDivisors R M
f : End R M
μ₁ : R
a✝ : μ₁ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
μ₂ : R
hμ₂ : μ₂ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
hμ₁₂ : ⨆ k, (f.genEigenspace μ₁) k = ⨆ k, (f.genEigenspace μ₂) k
⊢ μ₁ = μ₂
tactic: rintro μ₁ _ μ₂ hμ₂ (hμ₁₂ : ⨆ k, f.genEigenspace μ₁ k = ⨆ k, f.genEigenspace μ₂ k)
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
inst✝ : NoZeroSMulDivisors R M
f : End R M
μ₁ : R
a✝ : μ₁ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
μ₂ : R
hμ₂ : μ₂ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
hμ₁₂ : ⨆ k, (f.genEigenspace μ₁) k = ⨆ k, (f.genEigenspace μ₂) k
⊢ μ₁ = μ₂
state_after: 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
inst✝ : NoZeroSMulDivisors R M
f : End R M
μ₁ : R
a✝ : μ₁ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
μ₂ : R
hμ₂ : μ₂ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
hμ₁₂ : ⨆ k, (f.genEigenspace μ₁) k = ⨆ k, (f.genEigenspace μ₂) k
contra : ¬μ₁ = μ₂
⊢ False
tactic: by_contra contra
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
inst✝ : NoZeroSMulDivisors R M
f : End R M
μ₁ : R
a✝ : μ₁ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
μ₂ : R
hμ₂ : μ₂ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
hμ₁₂ : ⨆ k, (f.genEigenspace μ₁) k = ⨆ k, (f.genEigenspace μ₂) k
contra : ¬μ₁ = μ₂
⊢ False
state_after: 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
inst✝ : NoZeroSMulDivisors R M
f : End R M
μ₁ : R
a✝ : μ₁ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
μ₂ : R
hμ₂ : μ₂ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
hμ₁₂ : ⨆ k, (f.genEigenspace μ₁) k = ⨆ k, (f.genEigenspace μ₂) k
contra : ¬μ₁ = μ₂
⊢ ⨆ k, (f.genEigenspace μ₂) k = ⊥
tactic: apply hμ₂
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
inst✝ : NoZeroSMulDivisors R M
f : End R M
μ₁ : R
a✝ : μ₁ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
μ₂ : R
hμ₂ : μ₂ ∈ {μ | ⨆ k, (f.genEigenspace μ) k ≠ ⊥}
hμ₁₂ : ⨆ k, (f.genEigenspace μ₁) k = ⨆ k, (f.genEigenspace μ₂) k
contra : ¬μ₁ = μ₂
⊢ ⨆ k, (f.genEigenspace μ₂) k = ⊥
state_after: no goals
tactic: simpa only [hμ₁₂, disjoint_self] using f.disjoint_iSup_genEigenspace contra
Theorem: Filter.not_le
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f
state_after: no goals
tactic: simp_rw [le_def, not_forall, exists_prop]
Theorem: Subgroup.mul_mem_iff_of_index_two
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)
state_after: case pos
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∈ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)

case neg
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)
tactic: by_cases ha : a ∈ H
state_before: case neg
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)
state_after: case pos
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∈ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)

case neg
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)
tactic: by_cases hb : b ∈ H
state_before: case neg
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)
state_after: case neg
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
⊢ a * b ∈ H
tactic: simp only [ha, hb, iff_self_iff, iff_true_iff]
state_before: case neg
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
⊢ a * b ∈ H
state_after: case neg.intro
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
c : G
hc : ∀ (b : G), Xor' (b * c ∈ H) (b ∈ H)
⊢ a * b ∈ H
tactic: rcases index_eq_two_iff.1 h with ⟨c, hc⟩
state_before: case neg.intro
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
c : G
hc : ∀ (b : G), Xor' (b * c ∈ H) (b ∈ H)
⊢ a * b ∈ H
state_after: case neg.intro
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
c : G
hc : ∀ (b : G), Xor' (b * c ∈ H) (b ∈ H)
⊢ a * b * c ∉ H
tactic: refine (hc _).or.resolve_left ?_
state_before: case neg.intro
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
h : H.index = 2
a b : G
ha : a ∉ H
hb : b ∉ H
c : G
hc : ∀ (b : G), Xor' (b * c ∈ H) (b ∈ H)
⊢ a * b * c ∉ H
state_after: no goals
tactic: rwa [mul_assoc, mul_mem_cancel_right ((hc _).or.resolve_right hb)]
Theorem: Finset.sum_lt_sum_of_nonempty
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : s.Nonempty
hlt : ∀ i ∈ s, f i < g i
⊢ s.val ≠ ∅
state_after: no goals
tactic: aesop
Theorem: Rat.neg_divInt
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: n d : Int
⊢ -(n /. d) = -n /. d
state_after: no goals
tactic: rcases Int.eq_nat_or_neg d with ⟨_, rfl | rfl⟩ <;> simp [divInt_neg', neg_mkRat]
Theorem: Ordinal.log_def
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b : Ordinal.{u_1}
h : 1 < b
x : Ordinal.{u_1}
⊢ log b x = (sInf {o | x < b ^ o}).pred
state_after: no goals
tactic: simp only [log, dif_pos h]
Theorem: Matroid.closure_def'
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
M : Matroid α
X : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.closure X = ⋂₀ {F | M.Flat F ∧ X ⊆ F}
state_after: no goals
tactic: rw [closure, inter_eq_self_of_subset_left hX]
Theorem: WithTop.isGLB_sInf
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
⊢ IsGLB s (sInf s)
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : BddBelow s
⊢ IsGLB s (sInf s)

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : ¬BddBelow s
⊢ IsGLB s (sInf s)
tactic: by_cases hs : BddBelow s
Theorem: Nat.Ico_filter_modEq_cast
File: Mathlib/Data/Int/CardIntervalMod.lean

Proof steps:
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
⊢ map castEmbedding (filter (fun x => x ≡ v [MOD r]) (Ico a b)) = filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Ico ↑a ↑b)
state_after: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ x ∈ map castEmbedding (filter (fun x => x ≡ v [MOD r]) (Ico a b)) ↔ x ∈ filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Ico ↑a ↑b)
tactic: ext x
state_before: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ x ∈ map castEmbedding (filter (fun x => x ≡ v [MOD r]) (Ico a b)) ↔ x ∈ filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Ico ↑a ↑b)
state_after: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (∃ a_1, ((a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≡ v [MOD r]) ∧ ↑a_1 = x) ↔ (↑a ≤ x ∧ x < ↑b) ∧ x ≡ ↑v [ZMOD ↑r]
tactic: simp only [mem_map, mem_filter, mem_Ico, castEmbedding_apply]
state_before: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (∃ a_1, ((a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≡ v [MOD r]) ∧ ↑a_1 = x) ↔ (↑a ≤ x ∧ x < ↑b) ∧ x ≡ ↑v [ZMOD ↑r]
state_after: case a.mp
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (∃ a_1, ((a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≡ v [MOD r]) ∧ ↑a_1 = x) → (↑a ≤ x ∧ x < ↑b) ∧ x ≡ ↑v [ZMOD ↑r]

case a.mpr
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (↑a ≤ x ∧ x < ↑b) ∧ x ≡ ↑v [ZMOD ↑r] → ∃ a_2, ((a ≤ a_2 ∧ a_2 < b) ∧ a_2 ≡ v [MOD r]) ∧ ↑a_2 = x
tactic: constructor
Theorem: CategoryTheory.ShortComplex.rightHomology_ext
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasRightHomology
A : C
f₁ f₂ : A ⟶ S.rightHomology
h : f₁ ≫ S.rightHomologyι = f₂ ≫ S.rightHomologyι
⊢ f₁ = f₂
state_after: no goals
tactic: simpa only [rightHomology_ext_iff]
Theorem: mul_mul_div_cancel
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a * c * (b / c) = a * b
state_after: no goals
tactic: rw [mul_assoc, mul_div_cancel]
Theorem: Fintype.prod_eq_mul
File: Mathlib/Data/Fintype/BigOperators.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
M : Type u_4
inst✝¹ : Fintype α
inst✝ : CommMonoid M
f : α → M
a b : α
h₁ : a ≠ b
h₂ : ∀ (x : α), x ≠ a ∧ x ≠ b → f x = 1
⊢ ∏ x : α, f x = f a * f b
state_after: no goals
tactic: apply Finset.prod_eq_mul a b h₁ fun x _ hx => h₂ x hx <;>
    exact fun hc => (hc (Finset.mem_univ _)).elim
Theorem: Array.mem_join
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
⊢ ∀ {L : Array (Array α)}, a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l
state_after: α : Type u_1
a : α
⊢ ∀ {L : Array (Array α)}, (∃ l, (∃ a, a ∈ L.data ∧ a.data = l) ∧ a ∈ l) ↔ ∃ l, l ∈ L.data ∧ a ∈ l.data
tactic: simp only [mem_def, join_data, List.mem_join, List.mem_map]
state_before: α : Type u_1
a : α
⊢ ∀ {L : Array (Array α)}, (∃ l, (∃ a, a ∈ L.data ∧ a.data = l) ∧ a ∈ l) ↔ ∃ l, l ∈ L.data ∧ a ∈ l.data
state_after: α : Type u_1
a : α
l : Array (Array α)
⊢ (∃ l_1, (∃ a, a ∈ l.data ∧ a.data = l_1) ∧ a ∈ l_1) ↔ ∃ l_1, l_1 ∈ l.data ∧ a ∈ l_1.data
tactic: intro l
state_before: α : Type u_1
a : α
l : Array (Array α)
⊢ (∃ l_1, (∃ a, a ∈ l.data ∧ a.data = l_1) ∧ a ∈ l_1) ↔ ∃ l_1, l_1 ∈ l.data ∧ a ∈ l_1.data
state_after: case mp
α : Type u_1
a : α
l : Array (Array α)
⊢ (∃ l_1, (∃ a, a ∈ l.data ∧ a.data = l_1) ∧ a ∈ l_1) → ∃ l_1, l_1 ∈ l.data ∧ a ∈ l_1.data

case mpr
α : Type u_1
a : α
l : Array (Array α)
⊢ (∃ l_1, l_1 ∈ l.data ∧ a ∈ l_1.data) → ∃ l_1, (∃ a, a ∈ l.data ∧ a.data = l_1) ∧ a ∈ l_1
tactic: constructor
Theorem: List.headD_eq_head?
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: α : Type u_1
l : List α
a : α
⊢ l.headD a = l.head?.getD a
state_after: no goals
tactic: cases l <;> rfl
Theorem: DFinsupp.neLocus_sub_right
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ (f₁ - g).neLocus (f₂ - g) = f₁.neLocus f₂
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using @neLocus_add_right α N _ _ _ _ _ _
Theorem: CategoryTheory.FunctorToTypes.jointly_surjective
File: Mathlib/CategoryTheory/Limits/FunctorToTypes.lean

Proof steps:
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ TypeMax
k : K
t : Cocone F
h : IsColimit t
x : t.pt.obj k
⊢ ∃ j y, x = (t.ι.app j).app k y
state_after: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ TypeMax
k : K
t : Cocone F
h : IsColimit t
x : t.pt.obj k
hev : IsColimit (((evaluation K TypeMax).obj k).mapCocone t) := isColimitOfPreserves ((evaluation K TypeMax).obj k) h
⊢ ∃ j y, x = (t.ι.app j).app k y
tactic: let hev := isColimitOfPreserves ((evaluation _ _).obj k) h
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ TypeMax
k : K
t : Cocone F
h : IsColimit t
x : t.pt.obj k
hev : IsColimit (((evaluation K TypeMax).obj k).mapCocone t) := isColimitOfPreserves ((evaluation K TypeMax).obj k) h
⊢ ∃ j y, x = (t.ι.app j).app k y
state_after: case intro.intro
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ TypeMax
k : K
t : Cocone F
h : IsColimit t
hev : IsColimit (((evaluation K TypeMax).obj k).mapCocone t) := isColimitOfPreserves ((evaluation K TypeMax).obj k) h
j : J
y : (F ⋙ (evaluation K TypeMax).obj k).obj j
⊢ ∃ j_1 y_1, (((evaluation K TypeMax).obj k).mapCocone t).ι.app j y = (t.ι.app j_1).app k y_1
tactic: obtain ⟨j, y, rfl⟩ := Types.jointly_surjective _ hev x
state_before: case intro.intro
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ TypeMax
k : K
t : Cocone F
h : IsColimit t
hev : IsColimit (((evaluation K TypeMax).obj k).mapCocone t) := isColimitOfPreserves ((evaluation K TypeMax).obj k) h
j : J
y : (F ⋙ (evaluation K TypeMax).obj k).obj j
⊢ ∃ j_1 y_1, (((evaluation K TypeMax).obj k).mapCocone t).ι.app j y = (t.ι.app j_1).app k y_1
state_after: no goals
tactic: exact ⟨j, y, by simp⟩
Theorem: RelEmbedding.maximals_preimage_eq
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
y : Set β
⊢ maximals r (⇑f ⁻¹' y) = ⇑f ⁻¹' maximals s (y ∩ range ⇑f)
state_after: case h.e'_2.h.e'_3
α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
y : Set β
⊢ ⇑f ⁻¹' y = univ ∩ ⇑f ⁻¹' y

case h.e'_3
α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
y : Set β
⊢ ⇑f ⁻¹' maximals s (y ∩ range ⇑f) = univ ∩ ⇑f ⁻¹' maximals s (⇑f '' univ ∩ y)
tactic: convert (f.inter_preimage_maximals_eq univ y).symm
Theorem: Mathlib.Vector.mem_cons_iff
File: Mathlib/Data/Vector/Mem.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
v : Vector α n
⊢ a' ∈ (a ::ᵥ v).toList ↔ a' = a ∨ a' ∈ v.toList
state_after: no goals
tactic: rw [Vector.toList_cons, List.mem_cons]
Theorem: Multiset.range_add_eq_union
File: Mathlib/Data/Multiset/Range.lean

Proof steps:
state_before: a b : ℕ
⊢ range (a + b) = range a ∪ map (fun x => a + x) (range b)
state_after: a b : ℕ
⊢ (range a).Disjoint (map (fun x => a + x) (range b))
tactic: rw [range_add, add_eq_union_iff_disjoint]
state_before: a b : ℕ
⊢ (range a).Disjoint (map (fun x => a + x) (range b))
state_after: no goals
tactic: apply range_disjoint_map_add