ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Function.Antiperiodic.sub_nsmul_eq
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : AddGroup β
h : Antiperiodic f c
n : ℕ
⊢ f (x - n • c) = (-1) ^ n • f x
state_after: no goals
tactic: simpa only [Int.reduceNeg, natCast_zsmul] using h.sub_zsmul_eq n
Theorem: FreeAbelianGroup.toFinsupp_toFreeAbelianGroup
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
f : X →₀ ℤ
⊢ toFinsupp (toFreeAbelianGroup f) = f
state_after: no goals
tactic: rw [← AddMonoidHom.comp_apply, toFinsupp_comp_toFreeAbelianGroup, AddMonoidHom.id_apply]
Theorem: IsExtreme.trans
File: Mathlib/Analysis/Convex/Extreme.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hAB : IsExtreme 𝕜 A B
hBC : IsExtreme 𝕜 B C
⊢ IsExtreme 𝕜 A C
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hBC : IsExtreme 𝕜 B C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
⊢ x₁ ∈ C ∧ x₂ ∈ C
tactic: refine ⟨Subset.trans hBC.1 hAB.1, fun x₁ hx₁A x₂ hx₂A x hxC hx ↦ ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hBC : IsExtreme 𝕜 B C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
⊢ x₁ ∈ C ∧ x₂ ∈ C
state_after: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hBC : IsExtreme 𝕜 B C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
hx₁B : x₁ ∈ B
hx₂B : x₂ ∈ B
⊢ x₁ ∈ C ∧ x₂ ∈ C
tactic: obtain ⟨hx₁B, hx₂B⟩ := hAB.2 hx₁A hx₂A (hBC.1 hxC) hx
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hBC : IsExtreme 𝕜 B C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
hx₁B : x₁ ∈ B
hx₂B : x₂ ∈ B
⊢ x₁ ∈ C ∧ x₂ ∈ C
state_after: no goals
tactic: exact hBC.2 hx₁B hx₂B hxC hx
Theorem: UniformOnFun.continuous_rng_iff
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
X : Type u_5
inst✝ : TopologicalSpace X
f : X → α →ᵤ[𝔖] β
⊢ Continuous f ↔ ∀ s ∈ 𝔖, Continuous (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(toFun 𝔖) ∘ f)
state_after: no goals
tactic: simp only [continuous_iff_continuousAt, ContinuousAt,
    UniformOnFun.tendsto_iff_tendstoUniformlyOn, UniformFun.tendsto_iff_tendstoUniformly,
    tendstoUniformlyOn_iff_tendstoUniformly_comp_coe, @forall_swap X, Function.comp_apply,
    Function.comp_def, restrict_eq, UniformFun.toFun_ofFun]
Theorem: Complex.mul_I_re
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ (z * I).re = -z.im
state_after: no goals
tactic: simp
Theorem: Ideal.span_singleton_mul_le_iff
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ span {x} * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ (r : R), x ∣ r → ∀ s ∈ I, r * s ∈ J) ↔ ∀ z ∈ I, x * z ∈ J
tactic: simp only [mul_le, mem_span_singleton_mul, mem_span_singleton]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ (r : R), x ∣ r → ∀ s ∈ I, r * s ∈ J) ↔ ∀ z ∈ I, x * z ∈ J
state_after: case mp
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ (r : R), x ∣ r → ∀ s ∈ I, r * s ∈ J) → ∀ z ∈ I, x * z ∈ J

case mpr
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ z ∈ I, x * z ∈ J) → ∀ (r : R), x ∣ r → ∀ s ∈ I, r * s ∈ J
tactic: constructor
Theorem: Nat.add_eq_right
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ a + b = b ↔ a = 0
state_after: no goals
tactic: omega
Theorem: OreLocalization.nonempty_oreSet_iff
File: Mathlib/RingTheory/OreLocalization/OreSet.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
S : Submonoid R
⊢ Nonempty (OreSet S) ↔
    (∀ (r₁ r₂ : R) (s : ↥S), r₁ * ↑s = r₂ * ↑s → ∃ s', ↑s' * r₁ = ↑s' * r₂) ∧
      ∀ (r : R) (s : ↥S), ∃ r' s', ↑s' * r = r' * ↑s
state_after: case mp
R : Type u_1
inst✝ : Ring R
S : Submonoid R
⊢ Nonempty (OreSet S) →
    (∀ (r₁ r₂ : R) (s : ↥S), r₁ * ↑s = r₂ * ↑s → ∃ s', ↑s' * r₁ = ↑s' * r₂) ∧
      ∀ (r : R) (s : ↥S), ∃ r' s', ↑s' * r = r' * ↑s

case mpr
R : Type u_1
inst✝ : Ring R
S : Submonoid R
⊢ ((∀ (r₁ r₂ : R) (s : ↥S), r₁ * ↑s = r₂ * ↑s → ∃ s', ↑s' * r₁ = ↑s' * r₂) ∧
      ∀ (r : R) (s : ↥S), ∃ r' s', ↑s' * r = r' * ↑s) →
    Nonempty (OreSet S)
tactic: constructor
Theorem: SimpleGraph.egirth_eq_top
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

Proof steps:
state_before: α : Type u_1
G : SimpleGraph α
⊢ G.egirth = ⊤ ↔ G.IsAcyclic
state_after: no goals
tactic: simp [egirth, IsAcyclic]
Theorem: MulAction.IsBlock.def_one
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
⊢ IsBlock G B ↔ ∀ (g : G), g • B = B ∨ Disjoint (g • B) B
state_after: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
⊢ (∀ (g : G), g • B = B ∨ Disjoint (g • B) B) → IsBlock G B
tactic: refine ⟨IsBlock.smul_eq_or_disjoint, ?_⟩
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
⊢ (∀ (g : G), g • B = B ∨ Disjoint (g • B) B) → IsBlock G B
state_after: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
⊢ (∀ (g : G), g • B = B ∨ Disjoint (g • B) B) → ∀ (g g' : G), g • B = g' • B ∨ Disjoint (g • B) (g' • B)
tactic: rw [IsBlock.def]
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
⊢ (∀ (g : G), g • B = B ∨ Disjoint (g • B) B) → ∀ (g g' : G), g • B = g' • B ∨ Disjoint (g • B) (g' • B)
state_after: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
hB : ∀ (g : G), g • B = B ∨ Disjoint (g • B) B
g g' : G
⊢ g • B = g' • B ∨ Disjoint (g • B) (g' • B)
tactic: intro hB g g'
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
hB : ∀ (g : G), g • B = B ∨ Disjoint (g • B) B
g g' : G
⊢ g • B = g' • B ∨ Disjoint (g • B) (g' • B)
state_after: case f
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
hB : ∀ (g : G), g • B = B ∨ Disjoint (g • B) B
g g' : G
⊢ (g'⁻¹ * g) • B = B → g • B = g' • B

case g
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B : Set X
hB : ∀ (g : G), g • B = B ∨ Disjoint (g • B) B
g g' : G
⊢ Disjoint ((g'⁻¹ * g) • B) B → Disjoint (g • B) (g' • B)
tactic: apply (hB (g'⁻¹ * g)).imp
Theorem: List.pairwise_append_comm
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
s : ∀ {x y : α}, R x y → R y x
l₁ l₂ : List α
⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁)
state_after: α : Type u_1
R : α → α → Prop
s : ∀ {x y : α}, R x y → R y x
l₁ l₂ : List α
this :
  ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y
⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁)
tactic: have (l₁ l₂ : List α) (H : ∀ x : α, x ∈ l₁ → ∀ y : α, y ∈ l₂ → R x y)
    (x : α) (xm : x ∈ l₂) (y : α) (ym : y ∈ l₁) : R x y := s (H y ym x xm)
state_before: α : Type u_1
R : α → α → Prop
s : ∀ {x y : α}, R x y → R y x
l₁ l₂ : List α
this :
  ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y
⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁)
state_after: α : Type u_1
R : α → α → Prop
s : ∀ {x y : α}, R x y → R y x
l₁ l₂ : List α
this :
  ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y
⊢ (Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b) ↔
    Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₂ → ∀ (b : α), b ∈ l₁ → R a b
tactic: simp only [pairwise_append, and_left_comm]
state_before: α : Type u_1
R : α → α → Prop
s : ∀ {x y : α}, R x y → R y x
l₁ l₂ : List α
this :
  ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y
⊢ (Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b) ↔
    Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₂ → ∀ (b : α), b ∈ l₁ → R a b
state_after: no goals
tactic: rw [Iff.intro (this l₁ l₂) (this l₂ l₁)]
Theorem: CategoryTheory.Limits.imageSubobject_le
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y Z : C
f✝ : X✝ ⟶ Y
inst✝¹ : HasImage f✝
A B : C
X : Subobject B
f : A ⟶ B
inst✝ : HasImage f
h : A ⟶ underlying.obj X
w : h ≫ X.arrow = f
⊢ ((imageSubobjectIso f).hom ≫ image.lift (MonoFactorisation.mk (underlying.obj X) X.arrow h ⋯)) ≫ X.arrow =
    (imageSubobject f).arrow
state_after: no goals
tactic: rw [assoc, image.lift_fac, imageSubobject_arrow]
Theorem: GenContFract.conts_recurrence
File: Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean

Proof steps:
state_before: K : Type u_1
g : GenContFract K
n : ℕ
inst✝ : DivisionRing K
gp ppred pred : Pair K
succ_nth_s_eq : g.s.get? (n + 1) = some gp
nth_conts_eq : g.conts n = ppred
succ_nth_conts_eq : g.conts (n + 1) = pred
⊢ g.conts (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }
state_after: K : Type u_1
g : GenContFract K
n : ℕ
inst✝ : DivisionRing K
gp ppred pred : Pair K
succ_nth_s_eq : g.s.get? (n + 1) = some gp
nth_conts_eq : g.contsAux (n + 1) = ppred
succ_nth_conts_eq : g.contsAux (n + 1 + 1) = pred
⊢ g.conts (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }
tactic: rw [nth_cont_eq_succ_nth_contAux] at nth_conts_eq succ_nth_conts_eq
state_before: K : Type u_1
g : GenContFract K
n : ℕ
inst✝ : DivisionRing K
gp ppred pred : Pair K
succ_nth_s_eq : g.s.get? (n + 1) = some gp
nth_conts_eq : g.contsAux (n + 1) = ppred
succ_nth_conts_eq : g.contsAux (n + 1 + 1) = pred
⊢ g.conts (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }
state_after: no goals
tactic: exact conts_recurrenceAux succ_nth_s_eq nth_conts_eq succ_nth_conts_eq
Theorem: WithTop.add_coe_eq_top_iff
File: Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x✝ y✝ : α
x : WithTop α
y : α
⊢ x + ↑y = ⊤ ↔ x = ⊤
state_after: no goals
tactic: simp
Theorem: Matrix.isUnit_fromBlocks_zero₁₂
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A : Matrix m m α
C : Matrix n m α
D : Matrix n n α
⊢ IsUnit (fromBlocks A 0 C D) ↔ IsUnit A ∧ IsUnit D
state_after: no goals
tactic: simp only [← nonempty_invertible_iff_isUnit, ← nonempty_prod,
    (fromBlocksZero₁₂InvertibleEquiv _ _ _).nonempty_congr]
Theorem: orthonormal_empty
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
⊢ Orthonormal 𝕜 fun x => ↑x
state_after: no goals
tactic: classical
  simp [orthonormal_subtype_iff_ite]
Theorem: FreeAbelianGroup.support_zsmul
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
k : ℤ
h : k ≠ 0
a : FreeAbelianGroup X
⊢ (k • a).support = a.support
state_after: case a
X : Type u_1
k : ℤ
h : k ≠ 0
a : FreeAbelianGroup X
x : X
⊢ x ∈ (k • a).support ↔ x ∈ a.support
tactic: ext x
state_before: case a
X : Type u_1
k : ℤ
h : k ≠ 0
a : FreeAbelianGroup X
x : X
⊢ x ∈ (k • a).support ↔ x ∈ a.support
state_after: case a
X : Type u_1
k : ℤ
h : k ≠ 0
a : FreeAbelianGroup X
x : X
⊢ k • (coeff x) a ≠ 0 ↔ (coeff x) a ≠ 0
tactic: simp only [mem_support_iff, AddMonoidHom.map_zsmul]
state_before: case a
X : Type u_1
k : ℤ
h : k ≠ 0
a : FreeAbelianGroup X
x : X
⊢ k • (coeff x) a ≠ 0 ↔ (coeff x) a ≠ 0
state_after: no goals
tactic: simp only [h, zsmul_int_int, false_or_iff, Ne, mul_eq_zero]
Theorem: Ideal.dvdNotUnit_iff_lt
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : Ideal A
x✝ : DvdNotUnit I J
hI : I ≠ 0
H : Ideal A
hunit : ¬IsUnit H
hmul : J = I * H
h : J = I
⊢ I * H = I * 1
state_after: no goals
tactic: rw [← hmul, h, mul_one]
Theorem: CoxeterSystem.length_mul_simple_ne
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) ≠ cs.length w
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
⊢ False
tactic: intro eq
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
⊢ False
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
length_mod_two : cs.length (w * cs.simple i) % 2 = (cs.length w + cs.length (cs.simple i)) % 2
⊢ False
tactic: have length_mod_two := cs.length_mul_mod_two w (s i)
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
length_mod_two : cs.length (w * cs.simple i) % 2 = (cs.length w + cs.length (cs.simple i)) % 2
⊢ False
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
length_mod_two : cs.length w % 2 = (cs.length w + 1) % 2
⊢ False
tactic: rw [eq, length_simple] at length_mod_two
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
length_mod_two : cs.length w % 2 = (cs.length w + 1) % 2
⊢ False
state_after: case inl
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
length_mod_two : cs.length w % 2 = (cs.length w + 1) % 2
even : cs.length w % 2 = 0
⊢ False

case inr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
eq : cs.length (w * cs.simple i) = cs.length w
length_mod_two : cs.length w % 2 = (cs.length w + 1) % 2
odd : cs.length w % 2 = 1
⊢ False
tactic: rcases Nat.mod_two_eq_zero_or_one (ℓ w) with even | odd
Theorem: strictAntiOn_dual_iff
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ StrictAntiOn (⇑toDual ∘ f ∘ ⇑ofDual) s ↔ StrictAntiOn f s
state_after: no goals
tactic: rw [strictAntiOn_toDual_comp_iff, strictMonoOn_comp_ofDual_iff]
Theorem: ZFSet.pair_injective
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x x' y y' : ZFSet
H : x.pair y = x'.pair y'
⊢ x = x' ∧ y = y'
state_after: x x' y y' : ZFSet
H : x.pair y = x'.pair y'
ae : ∀ (z : ZFSet), z ∈ x.pair y ↔ z ∈ x'.pair y'
⊢ x = x' ∧ y = y'
tactic: have ae := ZFSet.ext_iff.1 H
state_before: x x' y y' : ZFSet
H : x.pair y = x'.pair y'
ae : ∀ (z : ZFSet), z ∈ x.pair y ↔ z ∈ x'.pair y'
⊢ x = x' ∧ y = y'
state_after: x x' y y' : ZFSet
H : x.pair y = x'.pair y'
ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x'} ∨ z = {x', y'}
⊢ x = x' ∧ y = y'
tactic: simp only [pair, mem_pair] at ae
state_before: x y y' : ZFSet
H : x.pair y = x.pair y'
ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'}
he : x = y → y = y'
⊢ x = x ∧ y = y'
state_after: case inl
x y y' : ZFSet
H : x.pair y = x.pair y'
ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'}
he : x = y → y = y'
xyx : {x, y} = {x}
⊢ x = x ∧ y = y'

case inr
x y y' : ZFSet
H : x.pair y = x.pair y'
ae : ∀ (z : ZFSet), z = {x} ∨ z = {x, y} ↔ z = {x} ∨ z = {x, y'}
he : x = y → y = y'
xyy' : {x, y} = {x, y'}
⊢ x = x ∧ y = y'
tactic: obtain xyx | xyy' := (ae {x, y}).1 (by simp)
Theorem: aeSeq.prop_of_mem_aeSeqSet
File: Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
⊢ p x fun n => aeSeq hf p n x
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
⊢ p x fun n => AEMeasurable.mk (f n) ⋯ x
tactic: simp only [aeSeq, hx, if_true]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
⊢ p x fun n => AEMeasurable.mk (f n) ⋯ x
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
⊢ p x fun n => f n x
tactic: rw [funext fun n => mk_eq_fun_of_mem_aeSeqSet hf hx n]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
⊢ p x fun n => f n x
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
h_ss : aeSeqSet hf p ⊆ {x | p x fun n => f n x}
⊢ p x fun n => f n x
tactic: have h_ss : aeSeqSet hf p ⊆ { x | p x fun n => f n x } := by
    rw [← compl_compl { x | p x fun n => f n x }, aeSeqSet, Set.compl_subset_compl]
    refine Set.Subset.trans (Set.compl_subset_compl.mpr ?_) (subset_toMeasurable _ _)
    exact fun x hx => hx.2
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
h_ss : aeSeqSet hf p ⊆ {x | p x fun n => f n x}
⊢ p x fun n => f n x
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
h_ss : aeSeqSet hf p ⊆ {x | p x fun n => f n x}
hx' : x ∈ {x | p x fun n => f n x}
⊢ p x fun n => f n x
tactic: have hx' := Set.mem_of_subset_of_mem h_ss hx
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i) μ
x : α
hx : x ∈ aeSeqSet hf p
h_ss : aeSeqSet hf p ⊆ {x | p x fun n => f n x}
hx' : x ∈ {x | p x fun n => f n x}
⊢ p x fun n => f n x
state_after: no goals
tactic: exact hx'
Theorem: AddCircle.coe_real_preimage_closedBall_eq_iUnion
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

Proof steps:
state_before: p x ε : ℝ
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε = ⋃ z, closedBall (x + z • p) ε
state_after: case inl
x ε : ℝ
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε = ⋃ z, closedBall (x + z • 0) ε

case inr
p x ε : ℝ
hp : p ≠ 0
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε = ⋃ z, closedBall (x + z • p) ε
tactic: rcases eq_or_ne p 0 with (rfl | hp)
state_before: case inr
p x ε : ℝ
hp : p ≠ 0
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε = ⋃ z, closedBall (x + z • p) ε
state_after: case inr.h
p x ε : ℝ
hp : p ≠ 0
y : ℝ
⊢ y ∈ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ↔ y ∈ ⋃ z, closedBall (x + z • p) ε
tactic: ext y
state_before: case inr.h
p x ε : ℝ
hp : p ≠ 0
y : ℝ
⊢ y ∈ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ↔ y ∈ ⋃ z, closedBall (x + z • p) ε
state_after: case inr.h
p x ε : ℝ
hp : p ≠ 0
y : ℝ
⊢ |y - x - ↑(round (p⁻¹ * (y - x))) * p| ≤ ε ↔ ∃ i, |y - x - ↑i * p| ≤ ε
tactic: simp only [dist_eq_norm, mem_preimage, mem_closedBall, zsmul_eq_mul, mem_iUnion, Real.norm_eq_abs,
    ← QuotientAddGroup.mk_sub, norm_eq, ← sub_sub]
state_before: case inr.h
p x ε : ℝ
hp : p ≠ 0
y : ℝ
⊢ |y - x - ↑(round (p⁻¹ * (y - x))) * p| ≤ ε ↔ ∃ i, |y - x - ↑i * p| ≤ ε
state_after: case inr.h
p x ε : ℝ
hp : p ≠ 0
y : ℝ
⊢ (∃ i, |y - x - ↑i * p| ≤ ε) → |y - x - ↑(round (p⁻¹ * (y - x))) * p| ≤ ε
tactic: refine ⟨fun h => ⟨round (p⁻¹ * (y - x)), h⟩, ?_⟩
state_before: case inr.h
p x ε : ℝ
hp : p ≠ 0
y : ℝ
⊢ (∃ i, |y - x - ↑i * p| ≤ ε) → |y - x - ↑(round (p⁻¹ * (y - x))) * p| ≤ ε
state_after: case inr.h.intro
p x ε : ℝ
hp : p ≠ 0
y : ℝ
n : ℤ
hn : |y - x - ↑n * p| ≤ ε
⊢ |y - x - ↑(round (p⁻¹ * (y - x))) * p| ≤ ε
tactic: rintro ⟨n, hn⟩
state_before: case inr.h.intro
p x ε : ℝ
hp : p ≠ 0
y : ℝ
n : ℤ
hn : |y - x - ↑n * p| ≤ ε
⊢ |y - x - ↑(round (p⁻¹ * (y - x))) * p| ≤ ε
state_after: case inr.h.intro
p x ε : ℝ
hp : p ≠ 0
y : ℝ
n : ℤ
hn : |p⁻¹ * (y - x) - ↑n| ≤ |p⁻¹| * ε
⊢ |p⁻¹ * (y - x) - ↑(round (p⁻¹ * (y - x)))| ≤ |p⁻¹| * ε
tactic: rw [← mul_le_mul_left (abs_pos.mpr <| inv_ne_zero hp), ← abs_mul, mul_sub, mul_comm _ p,
    inv_mul_cancel_left₀ hp] at hn ⊢
state_before: case inr.h.intro
p x ε : ℝ
hp : p ≠ 0
y : ℝ
n : ℤ
hn : |p⁻¹ * (y - x) - ↑n| ≤ |p⁻¹| * ε
⊢ |p⁻¹ * (y - x) - ↑(round (p⁻¹ * (y - x)))| ≤ |p⁻¹| * ε
state_after: no goals
tactic: exact (round_le (p⁻¹ * (y - x)) n).trans hn
Theorem: Set.image_seq
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : β → γ
s : Set (α → β)
t : Set α
⊢ f '' s.seq t = ((fun x => f ∘ x) '' s).seq t
state_after: no goals
tactic: simp only [seq, image_image2, image2_image_left, comp_apply]
Theorem: Multiset.sym2_map
File: Mathlib/Data/Multiset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
m : Multiset α
xs : List α
⊢ (map f ⟦xs⟧).sym2 = map (Sym2.map f) (Multiset.sym2 ⟦xs⟧)
state_after: no goals
tactic: simp [List.sym2_map]