ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.Set.sumDiffSubset_symm_apply_of_mem
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ (Set.sumDiffSubset h).symm x = Sum.inl ⟨↑x, hx⟩
state_after: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ (Set.sumDiffSubset h) ((Set.sumDiffSubset h).symm x) = (Set.sumDiffSubset h) (Sum.inl ⟨↑x, hx⟩)
tactic: apply (Equiv.Set.sumDiffSubset h).injective
state_before: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ (Set.sumDiffSubset h) ((Set.sumDiffSubset h).symm x) = (Set.sumDiffSubset h) (Sum.inl ⟨↑x, hx⟩)
state_after: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ x = inclusion h ⟨↑x, hx⟩
tactic: simp only [apply_symm_apply, sumDiffSubset_apply_inl]
state_before: case a
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s t : Set α
h : s ⊆ t
inst✝ : DecidablePred fun x => x ∈ s
x : ↑t
hx : ↑x ∈ s
⊢ x = inclusion h ⟨↑x, hx⟩
state_after: no goals
tactic: exact Subtype.eq rfl
Theorem: Profinite.NobelingProof.Products.eval_πs'
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
o₁ o₂ : Ordinal.{u}
h : o₁ ≤ o₂
hlt : ∀ i ∈ ↑l, ord I i < o₁
⊢ (πs' C h) (eval (π C fun x => ord I x < o₁) l) = eval (π C fun x => ord I x < o₂) l
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
o₁ o₂ : Ordinal.{u}
h : o₁ ≤ o₂
hlt : ∀ i ∈ ↑l, ord I i < o₁
⊢ ((πs' C h) (eval (π C fun x => ord I x < o₁) l)).toFun = ⇑(eval (π C fun x => ord I x < o₂) l)
tactic: rw [← LocallyConstant.coe_inj, ← LocallyConstant.toFun_eq_coe]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
o₁ o₂ : Ordinal.{u}
h : o₁ ≤ o₂
hlt : ∀ i ∈ ↑l, ord I i < o₁
⊢ ((πs' C h) (eval (π C fun x => ord I x < o₁) l)).toFun = ⇑(eval (π C fun x => ord I x < o₂) l)
state_after: no goals
tactic: exact evalFacProps C (fun (i : I) ↦ ord I i < o₁) (fun (i : I) ↦ ord I i < o₂) hlt
    (fun _ hh ↦ lt_of_lt_of_le hh h)
Theorem: SubMulAction.mem_one'
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A
r : R
⊢ (fun r => r • 1) r = x ↔ (algebraMap R A) r = x
state_after: no goals
tactic: rw [algebraMap_eq_smul_one]
Theorem: CategoryTheory.Presieve.restrict_extend
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
⊢ FamilyOfElements.restrict ⋯ x.sieveExtend = x
state_after: case h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y✝ : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
Y : C
f : Y ⟶ X
hf : R f
⊢ FamilyOfElements.restrict ⋯ x.sieveExtend f hf = x f hf
tactic: funext Y f hf
state_before: case h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y✝ : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
Y : C
f : Y ⟶ X
hf : R f
⊢ FamilyOfElements.restrict ⋯ x.sieveExtend f hf = x f hf
state_after: no goals
tactic: exact extend_agrees t hf
Theorem: MeasureTheory.Measure.addHaar_closedBall_mul_of_pos
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
tactic: have : closedBall (0 : E) (r * s) = r • closedBall (0 : E) s := by
    simp [smul_closedBall' hr.ne' (0 : E), abs_of_nonneg hr.le]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
state_after: no goals
tactic: simp only [this, addHaar_smul, abs_of_nonneg hr.le, addHaar_closedBall_center, abs_pow]
Theorem: Complex.integral_exp_neg_mul_rpow
File: Mathlib/MeasureTheory/Integral/Gamma.lean

Proof steps:
state_before: p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ ∫ (x : ℂ), rexp (-b * ‖x‖ ^ p) = π * b ^ (-2 / p) * Real.Gamma (2 / p + 1)
state_after: case h.e'_2
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ ∫ (x : ℂ), rexp (-b * ‖x‖ ^ p) = ∫ (x : ℂ), ‖x‖ ^ 0 * rexp (-b * ‖x‖ ^ p)

case h.e'_3
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ π * b ^ (-2 / p) * Real.Gamma (2 / p + 1) = 2 * π / p * b ^ (-(0 + 2) / p) * Real.Gamma ((0 + 2) / p)
tactic: convert (integral_rpow_mul_exp_neg_mul_rpow hp (by linarith : (-2 : ℝ) < 0)) hb using 1
Theorem: Matrix.fromRows_neg
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Neg R
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
⊢ -A₁.fromRows A₂ = (-A₁).fromRows (-A₂)
state_after: no goals
tactic: ext (i | i) j <;> simp
Theorem: List.sum_eq_zero_iff
File: Mathlib/Algebra/Order/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ l.prod = 1
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ ℕ

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l : List M
h : ∀ x ∈ l, x = 1
⊢ l.length = ?m.22276
tactic: rw [List.eq_replicate.2 ⟨_, h⟩, prod_replicate, one_pow]
Theorem: dvd_neg
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semigroup α
inst✝ : HasDistribNeg α
a b c : α
⊢ (∃ b_1, -b = a * (Equiv.symm (Equiv.neg α)) b_1) ↔ a ∣ b
state_after: no goals
tactic: simp only [Equiv.neg_symm, Equiv.neg_apply, mul_neg, neg_inj, Dvd.dvd]
Theorem: Stream'.nats_eq
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
⊢ nats = 0 :: map succ nats
state_after: case a
α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ), nats.get n = (0 :: map succ nats).get n
tactic: apply Stream'.ext
state_before: case a
α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ), nats.get n = (0 :: map succ nats).get n
state_after: case a
α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ nats.get n = (0 :: map succ nats).get n
tactic: intro n
state_before: case a
α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ nats.get n = (0 :: map succ nats).get n
state_after: case a.zero
α : Type u
β : Type v
δ : Type w
⊢ nats.get 0 = (0 :: map succ nats).get 0

case a.succ
α : Type u
β : Type v
δ : Type w
n✝ : ℕ
⊢ nats.get (n✝ + 1) = (0 :: map succ nats).get (n✝ + 1)
tactic: cases n
state_before: case a.succ
α : Type u
β : Type v
δ : Type w
n✝ : ℕ
⊢ nats.get (n✝ + 1) = (0 :: map succ nats).get (n✝ + 1)
state_after: case a.succ
α : Type u
β : Type v
δ : Type w
n✝ : ℕ
⊢ nats.tail.get n✝ = (0 :: map succ nats).get (n✝ + 1)
tactic: rw [get_succ]
state_before: case a.succ
α : Type u
β : Type v
δ : Type w
n✝ : ℕ
⊢ nats.tail.get n✝ = (0 :: map succ nats).get (n✝ + 1)
state_after: no goals
tactic: rfl
Theorem: Equiv.prod_assoc_symm_preimage
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ⇑(prodAssoc α β γ).symm ⁻¹' (s ×ˢ t) ×ˢ u = s ×ˢ t ×ˢ u
state_after: case h
α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
x✝ : α × β × γ
⊢ x✝ ∈ ⇑(prodAssoc α β γ).symm ⁻¹' (s ×ˢ t) ×ˢ u ↔ x✝ ∈ s ×ˢ t ×ˢ u
tactic: ext
state_before: case h
α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
x✝ : α × β × γ
⊢ x✝ ∈ ⇑(prodAssoc α β γ).symm ⁻¹' (s ×ˢ t) ×ˢ u ↔ x✝ ∈ s ×ˢ t ×ˢ u
state_after: no goals
tactic: simp [and_assoc]
Theorem: NNRat.divNat_mul_left
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ≥0
n₁ n₂ d₁ d₂ d✝ a : ℕ
ha : a ≠ 0
n d : ℕ
⊢ divNat (a * n) (a * d) = divNat n d
state_after: case a
p q : ℚ≥0
n₁ n₂ d₁ d₂ d✝ a : ℕ
ha : a ≠ 0
n d : ℕ
⊢ ↑(divNat (a * n) (a * d)) = ↑(divNat n d)
tactic: ext
state_before: case a
p q : ℚ≥0
n₁ n₂ d₁ d₂ d✝ a : ℕ
ha : a ≠ 0
n d : ℕ
⊢ ↑(divNat (a * n) (a * d)) = ↑(divNat n d)
state_after: case a
p q : ℚ≥0
n₁ n₂ d₁ d₂ d✝ a : ℕ
ha : a ≠ 0
n d : ℕ
⊢ Rat.divInt (↑a * ↑n) (↑a * ↑d) = Rat.divInt ↑n ↑d
tactic: push_cast
state_before: case a
p q : ℚ≥0
n₁ n₂ d₁ d₂ d✝ a : ℕ
ha : a ≠ 0
n d : ℕ
⊢ Rat.divInt (↑a * ↑n) (↑a * ↑d) = Rat.divInt ↑n ↑d
state_after: no goals
tactic: exact Rat.divInt_mul_left (mod_cast ha)
Theorem: IsAdjoinRootMonic.modByMonic_repr_map
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ h.repr (h.map g) - g
state_after: no goals
tactic: rw [← h.mem_ker_map, RingHom.sub_mem_ker_iff, map_repr]
Theorem: Valuation.RankOne.zero_of_hom_zero
File: Mathlib/RingTheory/Valuation/RankOne.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
⊢ x = 0
state_after: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
h_lt : 0 < x
⊢ False
tactic: refine (eq_of_le_of_not_lt (zero_le' (a := x)) fun h_lt ↦ ?_).symm
state_before: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
h_lt : 0 < x
⊢ False
state_after: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
h_lt : 0 < x
hs : (hom v) 0 < (hom v) x
⊢ False
tactic: have hs := strictMono v h_lt
state_before: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
h_lt : 0 < x
hs : (hom v) 0 < (hom v) x
⊢ False
state_after: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
h_lt : 0 < x
hs : 0 < 0
⊢ False
tactic: rw [_root_.map_zero, hx] at hs
state_before: R : Type u_1
inst✝² : Ring R
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
inst✝ : v.RankOne
x : Γ₀
hx : (hom v) x = 0
h_lt : 0 < x
hs : 0 < 0
⊢ False
state_after: no goals
tactic: exact hs.false
Theorem: isPreconnected_iff_subset_of_disjoint_closed
File: Mathlib/Topology/Connected/Clopen.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ IsPreconnected s ↔ ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v
state_after: case mp
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
h : IsPreconnected s
⊢ ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v

case mpr
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v
⊢ IsPreconnected s
tactic: constructor <;> intro h
Theorem: Submodule.equivSubtypeMap_symm_apply
File: Mathlib/Algebra/Module/Submodule/Equiv.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : Submodule R M
q : Submodule R ↥p
x : ↥(map p.subtype q)
⊢ ↑↑((p.equivSubtypeMap q).symm x) = ↑x
state_after: case mk
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : Submodule R M
q : Submodule R ↥p
val✝ : M
property✝ : val✝ ∈ map p.subtype q
⊢ ↑↑((p.equivSubtypeMap q).symm ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
tactic: cases x
state_before: case mk
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : Submodule R M
q : Submodule R ↥p
val✝ : M
property✝ : val✝ ∈ map p.subtype q
⊢ ↑↑((p.equivSubtypeMap q).symm ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: Algebra.mul_sub_algebraMap_pow_commutes
File: Mathlib/Algebra/Algebra/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
x : A
r : R
n : ℕ
⊢ x * (x - (algebraMap R A) r) ^ n = (x - (algebraMap R A) r) ^ n * x
state_after: case zero
R : Type u
S : Type v
A : Type w
B : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
x : A
r : R
⊢ x * (x - (algebraMap R A) r) ^ 0 = (x - (algebraMap R A) r) ^ 0 * x

case succ
R : Type u
S : Type v
A : Type w
B : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
x : A
r : R
n : ℕ
ih : x * (x - (algebraMap R A) r) ^ n = (x - (algebraMap R A) r) ^ n * x
⊢ x * (x - (algebraMap R A) r) ^ (n + 1) = (x - (algebraMap R A) r) ^ (n + 1) * x
tactic: induction' n with n ih
Theorem: MeasureTheory.Measure.haar.index_empty
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
V : Set G
⊢ index ∅ V = 0
state_after: G : Type u_1
inst✝ : Group G
V : Set G
⊢ 0 ∈ Finset.card '' {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V} ∨
    Finset.card '' {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V} = ∅
tactic: simp only [index, Nat.sInf_eq_zero]
state_before: G : Type u_1
inst✝ : Group G
V : Set G
⊢ 0 ∈ Finset.card '' {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V} ∨
    Finset.card '' {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V} = ∅
state_after: case h
G : Type u_1
inst✝ : Group G
V : Set G
⊢ 0 ∈ Finset.card '' {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}
tactic: left
state_before: case h
G : Type u_1
inst✝ : Group G
V : Set G
⊢ 0 ∈ Finset.card '' {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}
state_after: case h
G : Type u_1
inst✝ : Group G
V : Set G
⊢ ∅ ∈ {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V} ∧ ∅.card = 0
tactic: use ∅
state_before: case h
G : Type u_1
inst✝ : Group G
V : Set G
⊢ ∅ ∈ {t | ∅ ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V} ∧ ∅.card = 0
state_after: no goals
tactic: simp only [Finset.card_empty, empty_subset, mem_setOf_eq, eq_self_iff_true, and_self_iff]
Theorem: Finset.Nonempty.div_zero
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : GroupWithZero α
s t : Finset α
hs : s.Nonempty
⊢ 0 ⊆ s / 0
state_after: no goals
tactic: simpa [mem_div] using hs
Theorem: integral_cos_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, cos x ^ 2 = (cos b * sin b - cos a * sin a + b - a) / 2
state_after: no goals
tactic: field_simp [integral_cos_pow, add_sub_assoc]
Theorem: AddSubgroup.mem_normalizer_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
H K : Subgroup G
g : G
h : g ∈ H.normalizer
n : G
⊢ n * g ∈ H ↔ g * n ∈ H
state_after: no goals
tactic: rw [h, mul_assoc, mul_inv_cancel_right]
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
H K : Subgroup G
g : G
h : ∀ (n : G), n * g ∈ H ↔ g * n ∈ H
n : G
⊢ n ∈ H ↔ g * n * g⁻¹ ∈ H
state_after: no goals
tactic: rw [mul_assoc, ← h, inv_mul_cancel_right]
Theorem: DFinsupp.erase_eq_sub_single
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
⊢ erase i f = f - single i (f i)
state_after: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
⊢ (erase i f) j = (f - single i (f i)) j
tactic: ext j
state_before: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
⊢ (erase i f) j = (f - single i (f i)) j
state_after: case h.inl
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
⊢ (erase i f) i = (f - single i (f i)) i

case h.inr
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i j : ι
h : i ≠ j
⊢ (erase i f) j = (f - single i (f i)) j
tactic: rcases eq_or_ne i j with (rfl | h)
Theorem: Submonoid.mrange_inr
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inr M N) = ⊥.prod ⊤
state_after: no goals
tactic: simpa only [mrange_eq_map] using map_inr ⊤
Theorem: NumberField.is_primitive_element_of_infinitePlace_lt
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
x : 𝓞 K
w : InfinitePlace K
h₁ : x ≠ 0
h₂ : ∀ ⦃w' : InfinitePlace K⦄, w' ≠ w → w' ↑x < 1
h₃ : w.IsReal ∨ |(w.embedding ↑x).re| < 1
⊢ ℚ⟮↑x⟯ = ⊤
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
x : 𝓞 K
w : InfinitePlace K
h₁ : x ≠ 0
h₂ : ∀ ⦃w' : InfinitePlace K⦄, w' ≠ w → w' ↑x < 1
h₃ : w.IsReal ∨ |(w.embedding ↑x).re| < 1
⊢ ∀ (ψ : K →ₐ[ℚ] ℂ), w.embedding.toRatAlgHom ↑x = ψ ↑x → w.embedding.toRatAlgHom = ψ

k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
x : 𝓞 K
w : InfinitePlace K
h₁ : x ≠ 0
h₂ : ∀ ⦃w' : InfinitePlace K⦄, w' ≠ w → w' ↑x < 1
h₃ : w.IsReal ∨ |(w.embedding ↑x).re| < 1
⊢ ∀ (x : K), Polynomial.Splits (algebraMap ℚ ℂ) (minpoly ℚ x)
tactic: rw [Field.primitive_element_iff_algHom_eq_of_eval ℚ ℂ ?_ _ w.embedding.toRatAlgHom]
Theorem: Stream'.Seq1.join_map_ret
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ (Seq.map ret s).join = s
state_after: case H
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct
tactic: apply coinduction2 s
state_before: case H
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct
state_after: case H
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct
tactic: intro s
state_before: case H
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct
state_after: no goals
tactic: apply recOn s <;> simp [ret]
Theorem: Finset.singleton_subset_set_iff
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ : Finset α
a✝ b : α
s : Set α
a : α
⊢ ↑{a} ⊆ s ↔ a ∈ s
state_after: no goals
tactic: rw [coe_singleton, Set.singleton_subset_iff]
Theorem: NumberField.InfinitePlace.sum_mult_eq
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
⊢ ∑ w : InfinitePlace K, w.mult = FiniteDimensional.finrank ℚ K
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
⊢ ∑ w : InfinitePlace K, w.mult = ∑ j : InfinitePlace K, ∑ i ∈ Finset.filter (fun i => mk i = j) Finset.univ, 1
tactic: rw [← Embeddings.card K ℂ, Fintype.card, Finset.card_eq_sum_ones, ← Finset.univ.sum_fiberwise
    (fun φ => InfinitePlace.mk φ)]
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
⊢ ∑ w : InfinitePlace K, w.mult = ∑ j : InfinitePlace K, ∑ i ∈ Finset.filter (fun i => mk i = j) Finset.univ, 1
state_after: no goals
tactic: exact Finset.sum_congr rfl
    (fun _ _ => by rw [Finset.sum_const, smul_eq_mul, mul_one, card_filter_mk_eq])
Theorem: Filter.cofinite_eq_bot_iff
File: Mathlib/Order/Filter/Cofinite.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
⊢ cofinite = ⊥ ↔ Finite α
state_after: no goals
tactic: simp [← empty_mem_iff_bot, finite_univ_iff]