ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MultilinearMap.domDomCongrLinearEquiv_apply
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M₂
inst✝⁶ : Semiring S
inst✝⁵ : Module S M₂
inst✝⁴ : SMulCommClass R S M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
inst✝¹ : Module S M₃
inst✝ : SMulCommClass R S M₃
ι₁ : Type ?u.341072
ι₂ : Type ?u.341169
σ : ι₁ ≃ ι₂
c : S
f : MultilinearMap R (fun x => M₂) M₃
⊢ { toFun := __src✝.toFun, map_add' := ⋯ }.toFun (c • f) =
    (RingHom.id S) c • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun f
state_after: case H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M₂
inst✝⁶ : Semiring S
inst✝⁵ : Module S M₂
inst✝⁴ : SMulCommClass R S M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
inst✝¹ : Module S M₃
inst✝ : SMulCommClass R S M₃
ι₁ : Type ?u.341072
ι₂ : Type ?u.341169
σ : ι₁ ≃ ι₂
c : S
f : MultilinearMap R (fun x => M₂) M₃
x✝ : ι₂ → M₂
⊢ ({ toFun := __src✝.toFun, map_add' := ⋯ }.toFun (c • f)) x✝ =
    ((RingHom.id S) c • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun f) x✝
tactic: ext
state_before: case H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M₂
inst✝⁶ : Semiring S
inst✝⁵ : Module S M₂
inst✝⁴ : SMulCommClass R S M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
inst✝¹ : Module S M₃
inst✝ : SMulCommClass R S M₃
ι₁ : Type ?u.341072
ι₂ : Type ?u.341169
σ : ι₁ ≃ ι₂
c : S
f : MultilinearMap R (fun x => M₂) M₃
x✝ : ι₂ → M₂
⊢ ({ toFun := __src✝.toFun, map_add' := ⋯ }.toFun (c • f)) x✝ =
    ((RingHom.id S) c • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun f) x✝
state_after: no goals
tactic: simp [MultilinearMap.domDomCongr]
Theorem: TopCat.prod_topology
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ (X ⨯ Y).str = induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
state_after: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ (X ⨯ Y).str = induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
tactic: let homeo := homeoOfIso (prodIsoProd X Y)
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ (X ⨯ Y).str = induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
state_after: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ induced (⇑homeo) (of (↑X × ↑Y)).topologicalSpace_coe = induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
tactic: refine homeo.inducing.induced.trans ?_
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ induced (⇑homeo) (of (↑X × ↑Y)).topologicalSpace_coe = induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
state_after: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ induced (⇑homeo) (induced Prod.fst X.topologicalSpace_coe ⊓ induced Prod.snd Y.topologicalSpace_coe) =
    induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
tactic: change induced homeo (_ ⊓ _) = _
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ induced (⇑homeo) (induced Prod.fst X.topologicalSpace_coe ⊓ induced Prod.snd Y.topologicalSpace_coe) =
    induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
state_after: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ induced (Prod.fst ∘ ⇑homeo) X.topologicalSpace_coe ⊓ induced (Prod.snd ∘ ⇑homeo) Y.topologicalSpace_coe =
    induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
tactic: simp [induced_compose]
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
homeo : ↑(X ⨯ Y) ≃ₜ ↑(of (↑X × ↑Y)) := homeoOfIso (X.prodIsoProd Y)
⊢ induced (Prod.fst ∘ ⇑homeo) X.topologicalSpace_coe ⊓ induced (Prod.snd ∘ ⇑homeo) Y.topologicalSpace_coe =
    induced (⇑prod.fst) X.str ⊓ induced (⇑prod.snd) Y.str
state_after: no goals
tactic: rfl
Theorem: Filter.one_le_div_iff
File: Mathlib/Order/Filter/Pointwise.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✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
⊢ 1 ≤ f / g ↔ ¬Disjoint f g
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✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
h : 1 ≤ f / g
hfg : Disjoint f g
⊢ False

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
⊢ ¬Disjoint f g → 1 ≤ f / g
tactic: refine ⟨fun h hfg => ?_, ?_⟩
Theorem: DFinsupp.filter_single_pos
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✝ : ι
p : ι → Prop
inst✝ : DecidablePred p
i : ι
x : β i
h : p i
⊢ filter p (single i x) = single i x
state_after: no goals
tactic: rw [filter_single, if_pos h]
Theorem: HurwitzZeta.hurwitzZeta_residue_one
File: Mathlib/NumberTheory/LSeries/HurwitzZeta.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ Tendsto (fun s => (s - 1) * hurwitzZeta a s) (𝓝[≠] 1) (𝓝 1)
state_after: a : UnitAddCircle
⊢ Tendsto (fun s => (s - 1) * hurwitzZetaEven a s + (s - 1) * hurwitzZetaOdd a s) (𝓝[≠] 1)
    (𝓝 (1 + (1 - 1) * hurwitzZetaOdd a 1))
tactic: simp only [hurwitzZeta, mul_add, (by simp : 𝓝 (1 : ℂ) = 𝓝 (1 + (1 - 1) * hurwitzZetaOdd a 1))]
state_before: a : UnitAddCircle
⊢ Tendsto (fun s => (s - 1) * hurwitzZetaEven a s + (s - 1) * hurwitzZetaOdd a s) (𝓝[≠] 1)
    (𝓝 (1 + (1 - 1) * hurwitzZetaOdd a 1))
state_after: case refine_1
a : UnitAddCircle
⊢ Tendsto (fun s => s - 1) (𝓝 1) (𝓝 (1 - 1))

case refine_2
a : UnitAddCircle
⊢ Tendsto (hurwitzZetaOdd a) (𝓝 1) (𝓝 (hurwitzZetaOdd a 1))
tactic: refine (hurwitzZetaEven_residue_one a).add ((Tendsto.mul ?_ ?_).mono_left nhdsWithin_le_nhds)
state_before: case refine_1
a : UnitAddCircle
⊢ Tendsto (fun s => s - 1) (𝓝 1) (𝓝 (1 - 1))

case refine_2
a : UnitAddCircle
⊢ Tendsto (hurwitzZetaOdd a) (𝓝 1) (𝓝 (hurwitzZetaOdd a 1))
state_after: no goals
tactic: exacts [tendsto_id.sub_const _, (differentiable_hurwitzZetaOdd a).continuous.tendsto _]
Theorem: Metric.Sigma.dist_same
File: Mathlib/Topology/MetricSpace/Gluing.lean

Proof steps:
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
i : ι
x y : E i
⊢ dist ⟨i, x⟩ ⟨i, y⟩ = dist x y
state_after: no goals
tactic: simp [Dist.dist, Sigma.dist]
Theorem: SetTheory.PGame.birthday_moveLeft_lt
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: x : PGame
i : x.LeftMoves
⊢ (x.moveLeft i).birthday < x.birthday
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday < (mk α✝ β✝ a✝¹ a✝).birthday
tactic: cases x
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday < (mk α✝ β✝ a✝¹ a✝).birthday
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday < max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (a✝ i).birthday)
tactic: rw [birthday]
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday < max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (a✝ i).birthday)
state_after: no goals
tactic: exact lt_max_of_lt_left (lt_lsub _ i)
Theorem: Nat.or_exists_succ
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ (∃ n, p n) → p 0 ∨ ∃ n, p (n + 1)
state_after: case intro.zero
a b c d m n k : ℕ
p q : ℕ → Prop
hn : p 0
⊢ p 0 ∨ ∃ n, p (n + 1)

case intro.succ
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
hn : p (n + 1)
⊢ p 0 ∨ ∃ n, p (n + 1)
tactic: rintro ⟨_ | n, hn⟩
state_before: case intro.zero
a b c d m n k : ℕ
p q : ℕ → Prop
hn : p 0
⊢ p 0 ∨ ∃ n, p (n + 1)

case intro.succ
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
hn : p (n + 1)
⊢ p 0 ∨ ∃ n, p (n + 1)
state_after: no goals
tactic: exacts [Or.inl hn, Or.inr ⟨n, hn⟩]
Theorem: deriv_circleMap_eq_zero_iff
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ deriv (circleMap c R) θ = 0 ↔ R = 0
state_after: no goals
tactic: simp [I_ne_zero]
Theorem: Multiset.sum_smul_sum
File: Mathlib/Algebra/Module/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
s : Multiset R
t : Multiset M
⊢ s.sum • t.sum = (map (fun p => p.1 • p.2) (s ×ˢ t)).sum
state_after: case empty
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s : R
x y : M
t : Multiset M
⊢ sum 0 • t.sum = (map (fun p => p.1 • p.2) (0 ×ˢ t)).sum

case cons
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
t : Multiset M
a : R
s : Multiset R
ih : s.sum • t.sum = (map (fun p => p.1 • p.2) (s ×ˢ t)).sum
⊢ (a ::ₘ s).sum • t.sum = (map (fun p => p.1 • p.2) ((a ::ₘ s) ×ˢ t)).sum
tactic: induction' s using Multiset.induction with a s ih
Theorem: Wbtw.sameRay_vsub_right
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
h : Wbtw R x y z
⊢ SameRay R (z -ᵥ x) (z -ᵥ y)
state_after: case intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x z : P
t : R
left✝ : 0 ≤ t
ht1 : t ≤ 1
⊢ SameRay R (z -ᵥ x) (z -ᵥ (lineMap x z) t)
tactic: rcases h with ⟨t, ⟨_, ht1⟩, rfl⟩
state_before: case intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x z : P
t : R
left✝ : 0 ≤ t
ht1 : t ≤ 1
⊢ SameRay R (z -ᵥ x) (z -ᵥ (lineMap x z) t)
state_after: no goals
tactic: simpa [lineMap_apply, vsub_vadd_eq_vsub_sub, sub_smul] using
    SameRay.sameRay_nonneg_smul_right (z -ᵥ x) (sub_nonneg.2 ht1)
Theorem: MeasureTheory.lintegral_pos_iff_support
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ 0 < ∫⁻ (a : α), f a ∂μ ↔ 0 < μ (support f)
state_after: no goals
tactic: simp [pos_iff_ne_zero, hf, Filter.EventuallyEq, ae_iff, Function.support]
Theorem: CategoryTheory.Dial.associator_naturality
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ X₃ Y₁ Y₂ Y₃ : Dial C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ tensorHom (tensorHom f₁ f₂) f₃ ≫ (Y₁.associator Y₂ Y₃).hom =
    (X₁.associator X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃)
state_after: no goals
tactic: aesop_cat
Theorem: Tactic.ReduceModChar.CharP.neg_eq_sub_one_mul
File: Mathlib/Tactic/ReduceModChar.lean

Proof steps:
state_before: u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
inst : CharP α n
b : α
a : ℕ
a' : α
p : IsNat (↑n - 1) a
pa : ↑a = a'
⊢ -b = a' * b
state_after: u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
inst : CharP α n
b : α
a : ℕ
a' : α
p : IsNat (↑n - 1) a
pa : ↑a = a'
⊢ -1 * b = (↑n - 1) * b
tactic: rw [← pa, ← p.out, ← neg_one_mul]
state_before: u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
inst : CharP α n
b : α
a : ℕ
a' : α
p : IsNat (↑n - 1) a
pa : ↑a = a'
⊢ -1 * b = (↑n - 1) * b
state_after: no goals
tactic: simp
Theorem: PowerSeries.trunc_add
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ ψ : R⟦X⟧
m : ℕ
⊢ (trunc n (φ + ψ)).coeff m = (trunc n φ + trunc n ψ).coeff m
state_after: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ ψ : R⟦X⟧
m : ℕ
⊢ (if m < n then (coeff R m) (φ + ψ) else 0) = (if m < n then (coeff R m) φ else 0) + if m < n then (coeff R m) ψ else 0
tactic: simp only [coeff_trunc, AddMonoidHom.map_add, Polynomial.coeff_add]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ ψ : R⟦X⟧
m : ℕ
⊢ (if m < n then (coeff R m) (φ + ψ) else 0) = (if m < n then (coeff R m) φ else 0) + if m < n then (coeff R m) ψ else 0
state_after: case pos
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ ψ : R⟦X⟧
m : ℕ
H : m < n
⊢ (coeff R m) (φ + ψ) = (coeff R m) φ + (coeff R m) ψ

case neg
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ ψ : R⟦X⟧
m : ℕ
H : ¬m < n
⊢ 0 = 0 + 0
tactic: split_ifs with H
Theorem: FreeAddGroup.lift.range_le
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
⊢ (lift f).range ≤ s
state_after: case intro.mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
⊢ (lift f) (Quot.mk Red.Step L) ∈ s
tactic: rintro _ ⟨⟨L⟩, rfl⟩
state_before: case intro.mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
⊢ (lift f) (Quot.mk Red.Step L) ∈ s
state_after: no goals
tactic: exact List.recOn L s.one_mem fun ⟨x, b⟩ tl ih ↦
    Bool.recOn b (by simpa using s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
      (by simpa using s.mul_mem (H ⟨x, rfl⟩) ih)
Theorem: Equiv.Perm.not_mem_support
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ x ∉ f.support ↔ f x = x
state_after: no goals
tactic: simp
Theorem: powers.mul_mem
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
x y z : M
x✝¹ : y ∈ powers x
x✝ : z ∈ powers x
n₁ : ℕ
h₁ : x ^ n₁ = y
n₂ : ℕ
h₂ : x ^ n₂ = z
⊢ x ^ (n₁ + n₂) = y * z
state_after: no goals
tactic: simp only [pow_add, *]
Theorem: zsmul_right_injective
File: Mathlib/Algebra/Order/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedCommGroup α
n : ℤ
a b : α
hn : n ≠ 0
⊢ Injective fun x => x ^ n
state_after: case inl
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedCommGroup α
n : ℤ
a b : α
hn✝ : n ≠ 0
hn : n < 0
⊢ Injective fun x => x ^ n

case inr
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedCommGroup α
n : ℤ
a b : α
hn✝ : n ≠ 0
hn : 0 < n
⊢ Injective fun x => x ^ n
tactic: obtain hn | hn := hn.lt_or_lt
Theorem: Encodable.Subtype.encode_eq
File: Mathlib/Logic/Encodable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
P : α → Prop
encA : Encodable α
decP : DecidablePred P
a : Subtype P
⊢ encode a = encode ↑a
state_after: case mk
α : Type u_1
β : Type u_2
P : α → Prop
encA : Encodable α
decP : DecidablePred P
val✝ : α
property✝ : P val✝
⊢ encode ⟨val✝, property✝⟩ = encode ↑⟨val✝, property✝⟩
tactic: cases a
state_before: case mk
α : Type u_1
β : Type u_2
P : α → Prop
encA : Encodable α
decP : DecidablePred P
val✝ : α
property✝ : P val✝
⊢ encode ⟨val✝, property✝⟩ = encode ↑⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: Metric.cthickening_eq_iInter_thickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ cthickening δ E = ⋂ ε, ⋂ (_ : δ < ε), thickening ε E
state_after: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioi δ ∩ Ioc δ ε).Nonempty
tactic: apply cthickening_eq_iInter_thickening' δ_nn (Ioi δ) rfl.subset
state_before: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioi δ ∩ Ioc δ ε).Nonempty
state_after: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioc δ ε).Nonempty
tactic: simp_rw [inter_eq_right.mpr Ioc_subset_Ioi_self]
state_before: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioc δ ε).Nonempty
state_after: no goals
tactic: exact fun _ hε => nonempty_Ioc.mpr hε
Theorem: Matroid.not_dep_iff
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ ¬M.Dep X ↔ M.Indep X
state_after: no goals
tactic: rw [Dep, and_iff_left hX, not_not]
Theorem: NormedAddGroupHom.le_opNorm_of_le
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
x : V₁
h : ‖x‖ ≤ c
⊢ ‖f‖ * ‖x‖ ≤ ‖f‖ * c
state_after: case a0
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
x : V₁
h : ‖x‖ ≤ c
⊢ 0 ≤ ‖f‖
tactic: gcongr
state_before: case a0
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
c : ℝ
x : V₁
h : ‖x‖ ≤ c
⊢ 0 ≤ ‖f‖
state_after: no goals
tactic: exact f.opNorm_nonneg
Theorem: Int.natAbs_pow
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ n : ℤ
k : ℕ
⊢ (n ^ k).natAbs = n.natAbs ^ k
state_after: case zero
a b c d m n✝ n : ℤ
⊢ (n ^ 0).natAbs = n.natAbs ^ 0

case succ
a b c d m n✝ n : ℤ
k : ℕ
ih : (n ^ k).natAbs = n.natAbs ^ k
⊢ (n ^ (k + 1)).natAbs = n.natAbs ^ (k + 1)
tactic: induction' k with k ih
Theorem: Finset.sum_sub_sum_mem_addSpan
File: Mathlib/Combinatorics/Additive/Dissociation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : CommGroup α
inst✝² : CommGroup β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s t u : Finset α
a✝ : α
d : ℕ
ht : t ⊆ s
hu : u ⊆ s
a : α
⊢ ((↑t).indicator 1 - (↑u).indicator 1) a = -1 ∨
    ((↑t).indicator 1 - (↑u).indicator 1) a = 0 ∨ ((↑t).indicator 1 - (↑u).indicator 1) a = 1
state_after: no goals
tactic: by_cases a ∈ t <;> by_cases a ∈ u <;> simp [*]
state_before: α : Type u_1
β : Type u_2
inst✝³ : CommGroup α
inst✝² : CommGroup β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s t u : Finset α
a : α
d : ℕ
ht : t ⊆ s
hu : u ⊆ s
⊢ ∏ a ∈ s, a ^ ((↑t).indicator 1 - (↑u).indicator 1) a = (∏ a ∈ t, a) / ∏ a ∈ u, a
state_after: no goals
tactic: simp [prod_div_distrib, zpow_sub,
      ← div_eq_mul_inv, Set.indicator, pow_ite, inter_eq_right.2, *]
Theorem: Polynomial.nextCoeff_X_add_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c✝ d : R
n m : ℕ
inst✝² : Nontrivial R
inst✝¹ : Semiring R
inst✝ : Semiring S
c : S
⊢ (X + C c).nextCoeff = c
state_after: R : Type u
S : Type v
a b c✝ d : R
n m : ℕ
inst✝² : Nontrivial R
inst✝¹ : Semiring R
inst✝ : Semiring S
c : S
a✝ : Nontrivial S
⊢ (X + C c).nextCoeff = c
tactic: nontriviality S
state_before: R : Type u
S : Type v
a b c✝ d : R
n m : ℕ
inst✝² : Nontrivial R
inst✝¹ : Semiring R
inst✝ : Semiring S
c : S
a✝ : Nontrivial S
⊢ (X + C c).nextCoeff = c
state_after: no goals
tactic: simp [nextCoeff_of_natDegree_pos]
Theorem: CategoryTheory.biconeCategoryStruct_comp
File: Mathlib/CategoryTheory/Limits/Bicones.lean

Proof steps:
state_before: J : Type u₁
inst✝ : Category.{v₁, u₁} J
X✝ Y✝ Z✝ : Bicone J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝
state_after: case left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
g : Bicone.left ⟶ Z✝
⊢ Bicone.left ⟶ Z✝

case right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
g : Bicone.right ⟶ Z✝
⊢ Bicone.right ⟶ Z✝

case left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ Bicone.left ⟶ Z✝

case right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ Bicone.right ⟶ Z✝

case diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ k✝ : J
f : j✝ ⟶ k✝
g : Bicone.diagram k✝ ⟶ Z✝
⊢ Bicone.diagram j✝ ⟶ Z✝
tactic: rcases f with (_ | _ | _ | _ | f)
Theorem: Computation.length_think
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
h : s.Terminates
⊢ s.think.length = s.length + 1
state_after: case a
α : Type u
β : Type v
γ : Type w
s : Computation α
h : s.Terminates
⊢ s.think.length ≤ s.length + 1

case a
α : Type u
β : Type v
γ : Type w
s : Computation α
h : s.Terminates
⊢ s.length + 1 ≤ s.think.length
tactic: apply le_antisymm
Theorem: MeasureTheory.norm_integral_le_of_norm_le_const
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : IsFiniteMeasure μ
f : α → G
C : ℝ
h : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ ∫ (x : α), C ∂μ = C * (μ univ).toReal
state_after: no goals
tactic: rw [integral_const, smul_eq_mul, mul_comm]
Theorem: SpectrumRestricts.nnreal_iff
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
⊢ SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ ∀ x ∈ spectrum ℝ a, 0 ≤ x
state_after: case refine_1
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
h : SpectrumRestricts a ⇑ContinuousMap.realToNNReal
x : ℝ
hx : x ∈ spectrum ℝ a
⊢ 0 ≤ x

case refine_2
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
h : ∀ x ∈ spectrum ℝ a, 0 ≤ x
⊢ SpectrumRestricts a ⇑ContinuousMap.realToNNReal
tactic: refine ⟨fun h x hx ↦ ?_, fun h ↦ ?_⟩