ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.Perm.IsSwap.mul_mem_closure_three_cycles
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
hσ : σ.IsSwap
hτ : τ.IsSwap
⊢ σ * τ ∈ closure {σ | σ.IsThreeCycle}
state_after: case intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
τ : Perm α
hτ : τ.IsSwap
a b : α
ab : a ≠ b
⊢ swap a b * τ ∈ closure {σ | σ.IsThreeCycle}
tactic: obtain ⟨a, b, ab, rfl⟩ := hσ
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
τ : Perm α
hτ : τ.IsSwap
a b : α
ab : a ≠ b
⊢ swap a b * τ ∈ closure {σ | σ.IsThreeCycle}
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}
tactic: obtain ⟨c, d, cd, rfl⟩ := hτ
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}
state_after: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : a = c
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}

case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}
tactic: by_cases ac : a = c
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}
state_after: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}
tactic: have h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d) := by
    simp [swap_comm c a, mul_assoc]
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
⊢ swap a b * swap c d ∈ closure {σ | σ.IsThreeCycle}
state_after: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
⊢ swap a b * swap a c * (swap c a * swap c d) ∈ closure {σ | σ.IsThreeCycle}
tactic: rw [h']
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
⊢ swap a b * swap a c * (swap c a * swap c d) ∈ closure {σ | σ.IsThreeCycle}
state_after: no goals
tactic: exact
    mul_mem (swap_mul_swap_same_mem_closure_three_cycles ab ac)
      (swap_mul_swap_same_mem_closure_three_cycles (Ne.symm ac) cd)
Theorem: NNReal.eq_rpow_inv_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x✝ y✝ z✝ : ℝ
x y : ℝ≥0
z : ℝ
hz : z ≠ 0
⊢ x = y ^ z⁻¹ ↔ x ^ z = y
state_after: no goals
tactic: rw [← rpow_eq_rpow_iff hz, ← one_div, rpow_self_rpow_inv hz]
Theorem: CoalgebraCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_left
File: Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean

Proof steps:
state_before: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ Coalgebra.counit = Coalgebra.counit
state_after: case h
R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
x✝ : ↑((of R M ⊗ of R N) ⊗ of R P).toModuleCat
⊢ Coalgebra.counit x✝ = Coalgebra.counit x✝
tactic: ext
state_before: case h
R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
x✝ : ↑((of R M ⊗ of R N) ⊗ of R P).toModuleCat
⊢ Coalgebra.counit x✝ = Coalgebra.counit x✝
state_after: no goals
tactic: rfl
Theorem: Submodule.map₂_iSup_left
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

Proof steps:
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : ι → Submodule R M
t : Submodule R N
⊢ map₂ f (⨆ i, s i) t = ⨆ i, map₂ f (s i) t
state_after: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : ι → Submodule R M
t : Submodule R N
⊢ map₂ f (⨆ i, span R ↑(s i)) (span R ↑t) = ⨆ i, map₂ f (span R ↑(s i)) (span R ↑t)
tactic: suffices map₂ f (⨆ i, span R (s i : Set M)) (span R t) = ⨆ i, map₂ f (span R (s i)) (span R t) by
    simpa only [span_eq] using this
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : ι → Submodule R M
t : Submodule R N
⊢ map₂ f (⨆ i, span R ↑(s i)) (span R ↑t) = ⨆ i, map₂ f (span R ↑(s i)) (span R ↑t)
state_after: no goals
tactic: simp_rw [map₂_span_span, ← span_iUnion, map₂_span_span, Set.image2_iUnion_left]
Theorem: IsGenericPoint.mem_closed_set_iff
File: Mathlib/Topology/Sober.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
h : IsGenericPoint x S
hZ : IsClosed Z
⊢ x ∈ Z ↔ S ⊆ Z
state_after: no goals
tactic: rw [← h.def, hZ.closure_subset_iff, singleton_subset_iff]
Theorem: FreeAddMagma.lift_symm_apply
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Mul β
f : α → β
F : FreeMagma α →ₙ* β
⊢ (fun f => { toFun := liftAux f, map_mul' := ⋯ }) ((fun F => ⇑F ∘ of) F) = F
state_after: case h.h
α : Type u
β : Type v
inst✝ : Mul β
f : α → β
F : FreeMagma α →ₙ* β
x✝ : α
⊢ (⇑((fun f => { toFun := liftAux f, map_mul' := ⋯ }) ((fun F => ⇑F ∘ of) F)) ∘ of) x✝ = (⇑F ∘ of) x✝
tactic: ext
state_before: case h.h
α : Type u
β : Type v
inst✝ : Mul β
f : α → β
F : FreeMagma α →ₙ* β
x✝ : α
⊢ (⇑((fun f => { toFun := liftAux f, map_mul' := ⋯ }) ((fun F => ⇑F ∘ of) F)) ∘ of) x✝ = (⇑F ∘ of) x✝
state_after: no goals
tactic: rfl
Theorem: Ordinal.toPGame_moveLeft
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
i : ↑(Set.Iio o)
⊢ o.toPGame.moveLeft (toLeftMovesToPGame i) = (↑i).toPGame
state_after: no goals
tactic: simp
Theorem: ENNReal.toNNReal_sum
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
f : α → ℝ≥0∞
hf : ∀ a ∈ s, f a ≠ ⊤
⊢ (∑ a ∈ s, f a).toNNReal = ∑ a ∈ s, (f a).toNNReal
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
f : α → ℝ≥0∞
hf : ∀ a ∈ s, f a ≠ ⊤
⊢ ∀ x ∈ s, f x = ↑(f x).toNNReal

a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
f : α → ℝ≥0∞
hf : ∀ a ∈ s, f a ≠ ⊤
⊢ ∑ a ∈ s, f a ≠ ⊤
tactic: rw [← coe_inj, coe_toNNReal, coe_finset_sum, sum_congr rfl]
Theorem: CategoryTheory.Localization.Preadditive.add_eq
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
X' Y' Z' : D
eX : L.obj X ≅ X'
eY : L.obj Y ≅ Y'
eZ : L.obj Z ≅ Z'
f₁ f₂ : X' ⟶ Y'
⊢ f₁ + f₂ = add W eX eY f₁ f₂
state_after: no goals
tactic: apply add_eq_add
Theorem: AffineMap.homothety_add
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

Proof steps:
state_before: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c : P1
r₁ r₂ : k
⊢ homothety c (r₁ + r₂) = r₁ • (id k P1 -ᵥ const k P1 c) +ᵥ homothety c r₂
state_after: no goals
tactic: simp only [homothety_def, add_smul, vadd_vadd]
Theorem: ExteriorAlgebra.liftAlternating_ιMulti
File: Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
⊢ liftAlternating (ιMulti R) = LinearMap.id
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
v : ExteriorAlgebra R M
⊢ (liftAlternating (ιMulti R)) v = LinearMap.id v
tactic: ext v
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
v : ExteriorAlgebra R M
⊢ (liftAlternating (ιMulti R)) v = LinearMap.id v
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
v : ExteriorAlgebra R M
⊢ (liftAlternating (ιMulti R)) v = v
tactic: dsimp
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
v : ExteriorAlgebra R M
⊢ (liftAlternating (ιMulti R)) v = v
state_after: case h.algebraMap
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
r : R
⊢ (liftAlternating (ιMulti R)) ((algebraMap R (CliffordAlgebra 0)) r) = (algebraMap R (CliffordAlgebra 0)) r

case h.add
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
x y : CliffordAlgebra 0
hx : (liftAlternating (ιMulti R)) x = x
hy : (liftAlternating (ιMulti R)) y = y
⊢ (liftAlternating (ιMulti R)) (x + y) = x + y

case h.ι_mul
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
x : CliffordAlgebra 0
m : M
hx : (liftAlternating (ιMulti R)) x = x
⊢ (liftAlternating (ιMulti R)) ((CliffordAlgebra.ι 0) m * x) = (CliffordAlgebra.ι 0) m * x
tactic: induction' v using CliffordAlgebra.left_induction with r x y hx hy x m hx
Theorem: MeasureTheory.Measure.pi_closedBall
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝² : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝¹ : ∀ (i : ι), SigmaFinite (μ i)
inst✝ : (i : ι) → MetricSpace (α i)
x : (i : ι) → α i
r : ℝ
hr : 0 ≤ r
⊢ (Measure.pi μ) (Metric.closedBall x r) = ∏ i : ι, (μ i) (Metric.closedBall (x i) r)
state_after: no goals
tactic: rw [closedBall_pi _ hr, pi_pi]
Theorem: Complex.conj_neg_I
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: ⊢ ((starRingEnd ℂ) (-I)).re = I.re ∧ ((starRingEnd ℂ) (-I)).im = I.im
state_after: no goals
tactic: simp
Theorem: Asymptotics.IsBigO.trans_tendsto_norm_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
⊢ Tendsto (fun x => ‖v x‖) l atTop
state_after: case intro.intro
𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : c > 0
hcuv : IsBigOWith c l u v
⊢ Tendsto (fun x => ‖v x‖) l atTop
tactic: rcases huv.exists_pos with ⟨c, hc, hcuv⟩
state_before: case intro.intro
𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : c > 0
hcuv : IsBigOWith c l u v
⊢ Tendsto (fun x => ‖v x‖) l atTop
state_after: case intro.intro
𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : c > 0
hcuv : ∀ᶠ (x : α) in l, ‖u x‖ ≤ c * ‖v x‖
⊢ Tendsto (fun x => ‖v x‖) l atTop
tactic: rw [IsBigOWith] at hcuv
state_before: case intro.intro
𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : c > 0
hcuv : ∀ᶠ (x : α) in l, ‖u x‖ ≤ c * ‖v x‖
⊢ Tendsto (fun x => ‖v x‖) l atTop
state_after: case h.e'_3.h
𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : c > 0
hcuv : ∀ᶠ (x : α) in l, ‖u x‖ ≤ c * ‖v x‖
x✝ : α
⊢ ‖v x✝‖ = c * ‖v x✝‖ / c
tactic: convert Tendsto.atTop_div_const hc (tendsto_atTop_mono' l hcuv hu)
state_before: case h.e'_3.h
𝕜 : Type u_1
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_2
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : c > 0
hcuv : ∀ᶠ (x : α) in l, ‖u x‖ ≤ c * ‖v x‖
x✝ : α
⊢ ‖v x✝‖ = c * ‖v x✝‖ / c
state_after: no goals
tactic: rw [mul_div_cancel_left₀ _ hc.ne.symm]
Theorem: Finset.memberSubfamily_nonMemberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ memberSubfamily a (nonMemberSubfamily a 𝒜) = ∅
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ memberSubfamily a (nonMemberSubfamily a 𝒜) ↔ a✝ ∈ ∅
tactic: ext
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ memberSubfamily a (nonMemberSubfamily a 𝒜) ↔ a✝ ∈ ∅
state_after: no goals
tactic: simp
Theorem: Complex.cot_conj
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ ((starRingEnd ℂ) x).cot = (starRingEnd ℂ) x.cot
state_after: no goals
tactic: rw [cot, sin_conj, cos_conj, ← map_div₀, cot]
Theorem: sSup_compact_eq_top
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
⊢ sSup {a | CompleteLattice.IsCompactElement a} = ⊤
state_after: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
x : α
⊢ x ∈ {a | CompleteLattice.IsCompactElement a} ↔ x ∈ {c | CompleteLattice.IsCompactElement c ∧ c ≤ ⊤}
tactic: refine Eq.trans (congr rfl (Set.ext fun x => ?_)) (sSup_compact_le_eq ⊤)
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
x : α
⊢ x ∈ {a | CompleteLattice.IsCompactElement a} ↔ x ∈ {c | CompleteLattice.IsCompactElement c ∧ c ≤ ⊤}
state_after: no goals
tactic: exact (and_iff_left le_top).symm
Theorem: SetTheory.PGame.lf_def
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ x ⧏ y ↔
    (∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' ⧏ y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x ⧏ (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i ⧏ y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j ⧏ y.moveRight j'
state_after: xl xr : Type u
x y : PGame
⊢ ((∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y) ↔
    (∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' ⧏ y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x ⧏ (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i ⧏ y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j ⧏ y.moveRight j'
tactic: rw [lf_iff_exists_le]
state_before: xl xr : Type u
x y : PGame
⊢ ((∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y) ↔
    (∃ i,
        (∀ (i' : x.LeftMoves), x.moveLeft i' ⧏ y.moveLeft i) ∧
          ∀ (j : (y.moveLeft i).RightMoves), x ⧏ (y.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i ⧏ y) ∧
          ∀ (j' : y.RightMoves), x.moveRight j ⧏ y.moveRight j'
state_after: no goals
tactic: conv =>
    lhs
    simp only [le_iff_forall_lf]
Theorem: linearIndependent_option
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
v : Option ι → V
⊢ LinearIndependent K v ↔ LinearIndependent K (v ∘ some) ∧ v none ∉ span K (range (v ∘ some))
state_after: no goals
tactic: simp only [← linearIndependent_option', Option.casesOn'_none_coe]
Theorem: LipschitzWith.comp
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x✝ y✝ : α
r : ℝ≥0∞
Kf Kg : ℝ≥0
f : β → γ
g : α → β
hf : LipschitzWith Kf f
hg : LipschitzWith Kg g
x y : α
⊢ ↑Kf * (↑Kg * edist x y) = ↑(Kf * Kg) * edist x y
state_after: no goals
tactic: rw [← mul_assoc, ENNReal.coe_mul]
Theorem: lt_iff_transGen_covBy
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
x y : α
⊢ x < y ↔ TransGen (fun x x_1 => x ⋖ x_1) x y
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
x y : α
h : TransGen (fun x x_1 => x ⋖ x_1) x y
⊢ x < y
tactic: refine ⟨transGen_covBy_of_lt, fun h ↦ ?_⟩
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
x y : α
h : TransGen (fun x x_1 => x ⋖ x_1) x y
⊢ x < y
state_after: no goals
tactic: induction h with
  | single hx => exact hx.1
  | tail _ hb ih => exact ih.trans hb.1
Theorem: bernoulli_zero_fourier_coeff
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: n : ℤ
hn : n ≠ 0
⊢ bernoulliFourierCoeff 0 n = 0
state_after: no goals
tactic: simpa using bernoulliFourierCoeff_recurrence 0 hn
Theorem: Finset.mem_maximals_iff_forall_insert
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
P : Finset α → Prop
s : Finset α
hP : ∀ ⦃s t : Finset α⦄, P t → s ⊆ t → P s
⊢ s ∈ maximals (fun x x_1 => x ⊆ x_1) {t | P t} ↔ P s ∧ ∀ x ∉ s, ¬P (insert x s)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
P : Finset α → Prop
s : Finset α
hP : ∀ ⦃s t : Finset α⦄, P t → s ⊆ t → P s
⊢ P s → ((∀ ⦃y : Finset α⦄, P y → s ⊆ y → s = y) ↔ ∀ x ∉ s, ¬P (insert x s))
tactic: simp only [mem_maximals_iff, and_congr_right_iff, Set.mem_setOf_eq]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
P : Finset α → Prop
s : Finset α
hP : ∀ ⦃s t : Finset α⦄, P t → s ⊆ t → P s
⊢ P s → ((∀ ⦃y : Finset α⦄, P y → s ⊆ y → s = y) ↔ ∀ x ∉ s, ¬P (insert x s))
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
P : Finset α → Prop
s : Finset α
hP : ∀ ⦃s t : Finset α⦄, P t → s ⊆ t → P s
x✝ : P s
h : ∀ ⦃y : Finset α⦄, P y → s ⊆ y → s = y
x : α
hx : x ∉ s
hxs : P (insert x s)
⊢ x ∈ s

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
P : Finset α → Prop
s : Finset α
hP : ∀ ⦃s t : Finset α⦄, P t → s ⊆ t → P s
x✝ : P s
h : ∀ x ∉ s, ¬P (insert x s)
t : Finset α
ht : P t
hst : s ⊆ t
x : α
hxt : x ∈ t
⊢ x ∈ s
tactic: refine fun _ ↦ ⟨fun h x hx hxs ↦ hx ?_, fun h t ht hst ↦ hst.antisymm fun x hxt ↦ ?_⟩
state_before: case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
P : Finset α → Prop
s : Finset α
hP : ∀ ⦃s t : Finset α⦄, P t → s ⊆ t → P s
x✝ : P s
h : ∀ x ∉ s, ¬P (insert x s)
t : Finset α
ht : P t
hst : s ⊆ t
x : α
hxt : x ∈ t
⊢ x ∈ s
state_after: no goals
tactic: exact by_contra fun hxs ↦ h x hxs (hP ht (insert_subset hxt hst))
Theorem: Cubic.natDegree_of_b_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
⊢ P.toPoly.natDegree ≤ 1
state_after: no goals
tactic: simpa only [of_b_eq_zero ha hb] using natDegree_linear_le
Theorem: CategoryTheory.NatTrans.mapHomotopyCategory_id
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : Semiring R
ι : Type u_2
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝² : Category.{u_4, u_3} W
inst✝¹ : Preadditive W
c : ComplexShape ι
F : V ⥤ W
inst✝ : F.Additive
⊢ mapHomotopyCategory (𝟙 F) c = 𝟙 (F.mapHomotopyCategory c)
state_after: no goals
tactic: aesop_cat
Theorem: Real.Angle.abs_cos_eq_of_two_zsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ |θ.cos| = |ψ.cos|
state_after: no goals
tactic: exact abs_cos_eq_of_two_nsmul_eq h
Theorem: CochainComplex.HomComplex.Cochain.ofHoms_comp
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
φ : (p : ℤ) → F.X p ⟶ G.X p
ψ : (p : ℤ) → G.X p ⟶ K.X p
⊢ (ofHoms φ).comp (ofHoms ψ) ⋯ = ofHoms fun p => φ p ≫ ψ p
state_after: no goals
tactic: aesop_cat