ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.mem_shatterer
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
⊢ s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
⊢ s ∈ 𝒜.biUnion powerset
tactic: refine mem_filter.trans <| and_iff_right_of_imp fun h ↦ ?_
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
⊢ s ∈ 𝒜.biUnion powerset
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
⊢ ∃ a ∈ 𝒜, s ⊆ a
tactic: simp_rw [mem_biUnion, mem_powerset]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.Shatters s
⊢ ∃ a ∈ 𝒜, s ⊆ a
state_after: no goals
tactic: exact h.exists_superset
Theorem: NonUnitalAlgebra.coe_iInf
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
ι : Sort u_2
S : ι → NonUnitalSubalgebra R A
⊢ ↑(⨅ i, S i) = ⋂ i, ↑(S i)
state_after: no goals
tactic: simp [iInf]
Theorem: PosNum.size_to_nat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : PosNum
⊢ ↑n.bit0.size = (↑n.bit0).size
state_after: α : Type u_1
n : PosNum
⊢ (↑n).size + 1 = (2 * ↑n).size
tactic: rw [size, succ_to_nat, size_to_nat n, cast_bit0, ← two_mul]
state_before: α : Type u_1
n : PosNum
⊢ (↑n).size + 1 = (2 * ↑n).size
state_after: α : Type u_1
n : PosNum
⊢ Nat.bit false ↑n ≠ 0
tactic: erw [@Nat.size_bit false n]
state_before: α : Type u_1
n : PosNum
⊢ Nat.bit false ↑n ≠ 0
state_after: α : Type u_1
n : PosNum
this : 0 < ↑n
⊢ Nat.bit false ↑n ≠ 0
tactic: have := to_nat_pos n
state_before: α : Type u_1
n : PosNum
this : 0 < ↑n
⊢ Nat.bit false ↑n ≠ 0
state_after: α : Type u_1
n : PosNum
this : 0 < ↑n
⊢ ¬2 * ↑n = 0
tactic: dsimp [Nat.bit]
state_before: α : Type u_1
n : PosNum
this : 0 < ↑n
⊢ ¬2 * ↑n = 0
state_after: no goals
tactic: omega
state_before: α : Type u_1
n : PosNum
⊢ ↑n.bit1.size = (↑n.bit1).size
state_after: α : Type u_1
n : PosNum
⊢ (↑n).size + 1 = (2 * ↑n + 1).size
tactic: rw [size, succ_to_nat, size_to_nat n, cast_bit1, ← two_mul]
state_before: α : Type u_1
n : PosNum
⊢ (↑n).size + 1 = (2 * ↑n + 1).size
state_after: α : Type u_1
n : PosNum
⊢ Nat.bit true ↑n ≠ 0
tactic: erw [@Nat.size_bit true n]
state_before: α : Type u_1
n : PosNum
⊢ Nat.bit true ↑n ≠ 0
state_after: α : Type u_1
n : PosNum
⊢ ¬2 * ↑n + 1 = 0
tactic: dsimp [Nat.bit]
state_before: α : Type u_1
n : PosNum
⊢ ¬2 * ↑n + 1 = 0
state_after: no goals
tactic: omega
Theorem: CategoryTheory.ShortComplex.rightHomologyι_descOpcycles_π_eq_zero_of_boundary
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.217781, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝ : S.HasRightHomology
x : S.X₃ ⟶ A
hx : k = S.g ≫ x
⊢ S.f ≫ k = 0
state_after: no goals
tactic: rw [hx, S.zero_assoc, zero_comp]
Theorem: map_mul_left_nhds_one₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ map (fun x => a * x) (𝓝 1) = 𝓝 a
state_after: no goals
tactic: rw [map_mul_left_nhds₀ ha, mul_one]
Theorem: LinearMap.BilinForm.smul_right_of_tower
File: Mathlib/LinearAlgebra/BilinearForm/Basic.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
r : S
x y : M
⊢ (B x) (r • y) = r • (B x) y
state_after: no goals
tactic: rw [← IsScalarTower.algebraMap_smul R r, smul_right, Algebra.smul_def]
Theorem: Matrix.dotProduct_zero
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ v ⬝ᵥ 0 = 0
state_after: no goals
tactic: simp [dotProduct]
Theorem: Real.one_le_cosh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

Proof steps:
state_before: x✝ y z x : ℝ
⊢ |0| ≤ |x|
state_after: no goals
tactic: simp only [_root_.abs_zero, _root_.abs_nonneg]
Theorem: Set.inter_indicator_one
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroOneClass M₀
s t : Set ι
i x✝ : ι
⊢ (s ∩ t).indicator 1 x✝ = (s.indicator 1 * t.indicator 1) x✝
state_after: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroOneClass M₀
s t : Set ι
i x✝ : ι
⊢ (s ∩ t).indicator 1 x✝ = (s ∩ t).indicator (fun j => 1) x✝
tactic: simp only [← inter_indicator_mul, Pi.mul_apply, Pi.one_apply, one_mul]
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : MulZeroOneClass M₀
s t : Set ι
i x✝ : ι
⊢ (s ∩ t).indicator 1 x✝ = (s ∩ t).indicator (fun j => 1) x✝
state_after: no goals
tactic: congr
Theorem: List.replaceF_of_forall_none
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Option α
l : List α
h : ∀ (a : α), a ∈ l → p a = none
⊢ replaceF p l = l
state_after: no goals
tactic: induction l with
  | nil => rfl
  | cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2]
Theorem: MvPolynomial.decomposition.decompose'_eq
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝ : CommSemiring R
⊢ DirectSum.Decomposition.decompose' = fun φ =>
    (DirectSum.mk (fun i => ↥(homogeneousSubmodule σ R i)) (Finset.image Finsupp.degree φ.support)) fun m =>
      ⟨(homogeneousComponent ↑m) φ, ⋯⟩
state_after: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝ : CommSemiring R
⊢ DirectSum.Decomposition.decompose' = fun φ =>
    (DirectSum.mk (fun i => ↥(homogeneousSubmodule σ R i)) (Finset.image (⇑(weight 1)) φ.support)) fun m =>
      ⟨(homogeneousComponent ↑m) φ, ⋯⟩
tactic: rw [degree_eq_weight_one]
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝ : CommSemiring R
⊢ DirectSum.Decomposition.decompose' = fun φ =>
    (DirectSum.mk (fun i => ↥(homogeneousSubmodule σ R i)) (Finset.image (⇑(weight 1)) φ.support)) fun m =>
      ⟨(homogeneousComponent ↑m) φ, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: mul_inv_lt_of_lt_mul₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a < b * c
⊢ a * c⁻¹ < b
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : b ≤ a * c⁻¹
⊢ b * c ≤ a
tactic: contrapose! h
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : b ≤ a * c⁻¹
⊢ b * c ≤ a
state_after: no goals
tactic: simpa only [inv_inv] using mul_inv_le_of_le_mul h
Theorem: QuaternionGroup.orderOf_a
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

Proof steps:
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (a i) = 2 * n / (2 * n).gcd i.val
state_after: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (a ↑i.val) = 2 * n / (2 * n).gcd i.val
tactic: conv_lhs => rw [← ZMod.natCast_zmod_val i]
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (a ↑i.val) = 2 * n / (2 * n).gcd i.val
state_after: no goals
tactic: rw [← a_one_pow, orderOf_pow, orderOf_a_one]
Theorem: Set.add_smul_subset
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
a b : α
s : Set β
⊢ (a + b) • s ⊆ a • s + b • s
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
a b : α
s : Set β
x : β
hx : x ∈ s
⊢ (fun x => (a + b) • x) x ∈ a • s + b • s
tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
a b : α
s : Set β
x : β
hx : x ∈ s
⊢ (fun x => (a + b) • x) x ∈ a • s + b • s
state_after: no goals
tactic: simpa only [add_smul] using add_mem_add (smul_mem_smul_set hx) (smul_mem_smul_set hx)
Theorem: Filter.prod_def
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f : Filter α
g : Filter β
⊢ f ×ˢ g = f.lift fun s => g.lift' fun t => s ×ˢ t
state_after: no goals
tactic: simpa only [Filter.lift', Filter.lift, (f.basis_sets.prod g.basis_sets).eq_biInf,
    iInf_prod, iInf_and] using iInf_congr fun i => iInf_comm
Theorem: Ideal.span_singleton_eq_top
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
x : α
⊢ span {x} = ⊤ ↔ IsUnit x
state_after: no goals
tactic: rw [isUnit_iff_dvd_one, ← span_singleton_le_span_singleton, span_singleton_one, eq_top_iff]
Theorem: Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ (2 • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2
state_after: no goals
tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_toReal_eq_two_mul_add_two_pi]
Theorem: PartialEquiv.eq_symm_apply
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
x : α
y : β
hx : x ∈ e.source
hy : y ∈ e.target
h : x = ↑e.symm y
⊢ ↑e x = y
state_after: no goals
tactic: rw [← e.right_inv hy, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
x : α
y : β
hx : x ∈ e.source
hy : y ∈ e.target
h : ↑e x = y
⊢ x = ↑e.symm y
state_after: no goals
tactic: rw [← e.left_inv hx, h]
Theorem: TopologicalSpace.Opens.set_range_forget_map_inclusion
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X : TopCat
U : Opens ↑X
⊢ Set.range ((forget TopCat).map U.inclusion) = ↑U
state_after: case h
X : TopCat
U : Opens ↑X
x : (forget TopCat).obj X
⊢ x ∈ Set.range ((forget TopCat).map U.inclusion) ↔ x ∈ ↑U
tactic: ext x
state_before: case h
X : TopCat
U : Opens ↑X
x : (forget TopCat).obj X
⊢ x ∈ Set.range ((forget TopCat).map U.inclusion) ↔ x ∈ ↑U
state_after: case h.mp
X : TopCat
U : Opens ↑X
x : (forget TopCat).obj X
⊢ x ∈ Set.range ((forget TopCat).map U.inclusion) → x ∈ ↑U

case h.mpr
X : TopCat
U : Opens ↑X
x : (forget TopCat).obj X
⊢ x ∈ ↑U → x ∈ Set.range ((forget TopCat).map U.inclusion)
tactic: constructor
Theorem: CategoryTheory.Functor.final_iff_of_isFiltered
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final ↔
    (∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
      ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c), ∃ c' t, s ≫ F.map t = s' ≫ F.map t
state_after: case refine_1
C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
hF : F.Final
⊢ ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)

case refine_2
C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
hF : F.Final
⊢ ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c), ∃ c' t, s ≫ F.map t = s' ≫ F.map t
tactic: refine ⟨fun hF => ⟨?_, ?_⟩, fun h => final_of_exists_of_isFiltered F h.1 h.2⟩
Theorem: ContinuousMultilinearMap.opNorm_zero
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ m : (i : ι) → E i
⊢ ‖0 m‖ ≤ 0 * ∏ i : ι, ‖m i‖
state_after: no goals
tactic: simp
Theorem: SignType.range_eq
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α : Type u_1
f : SignType → α
⊢ Set.range f = {f zero, f neg, f pos}
state_after: α : Type u_1
f : SignType → α
⊢ ↑(Finset.image f {0, -1, 1}) = {f zero, f neg, f pos}
tactic: classical rw [← Fintype.coe_image_univ, univ_eq]
state_before: α : Type u_1
f : SignType → α
⊢ ↑(Finset.image f {0, -1, 1}) = {f zero, f neg, f pos}
state_after: no goals
tactic: classical simp [Finset.coe_insert]
Theorem: CategoryTheory.Functor.lanAdjunction_unit
File: Mathlib/CategoryTheory/Functor/KanExtension/Adjunction.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasLeftKanExtension F
⊢ (L.lanAdjunction H).unit = L.lanUnit
state_after: case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasLeftKanExtension F
F : C ⥤ H
⊢ (L.lanAdjunction H).unit.app F = L.lanUnit.app F
tactic: ext F : 2
state_before: case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasLeftKanExtension F
F : C ⥤ H
⊢ (L.lanAdjunction H).unit.app F = L.lanUnit.app F
state_after: case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasLeftKanExtension F
F : C ⥤ H
⊢ L.lanUnit.app F ≫ 𝟙 (L ⋙ L.lan.obj F) = L.lanUnit.app F
tactic: dsimp [lanAdjunction, homEquivOfIsLeftKanExtension]
state_before: case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasLeftKanExtension F
F : C ⥤ H
⊢ L.lanUnit.app F ≫ 𝟙 (L ⋙ L.lan.obj F) = L.lanUnit.app F
state_after: no goals
tactic: simp
Theorem: Polynomial.mirror_leadingCoeff
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ p.mirror.leadingCoeff = p.trailingCoeff
state_after: no goals
tactic: rw [← p.mirror_mirror, mirror_trailingCoeff, p.mirror_mirror]
Theorem: seminormFromBounded_eq_zero_iff
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
⊢ seminormFromBounded' f x = 0 ↔ f x = 0
state_after: case refine_1
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
h : seminormFromBounded' f x = 0
⊢ f x = 0

case refine_2
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
h : f x = 0
⊢ seminormFromBounded' f x = 0
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: List.take_sum_join
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : ℕ
⊢ take (take i (map length L)).sum L.join = (take i L).join
state_after: no goals
tactic: simpa using take_sum_join' _ _
Theorem: WithBot.preimage_coe_Ioi_bot
File: Mathlib/Order/Interval/Set/WithBotTop.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some ⁻¹' Ioi ⊥ = univ
state_after: no goals
tactic: rw [← range_coe, preimage_range]
Theorem: Order.Ico_succ_left_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
⊢ Ico (succ a) b = Ioo a b
state_after: no goals
tactic: rw [← Ici_inter_Iio, Ici_succ_of_not_isMax ha, Ioi_inter_Iio]
Theorem: Complex.eq_re_of_ofReal_le
File: Mathlib/Data/Complex/Order.lean

Proof steps:
state_before: r : ℝ
z : ℂ
hz : ↑r ≤ z
⊢ z = ↑z.re
state_after: no goals
tactic: rw [eq_comm, ← conj_eq_iff_re, conj_eq_iff_im, ← (Complex.le_def.1 hz).2, Complex.ofReal_im]
Theorem: add_tsub_add_le_tsub_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + c - (b + c) ≤ a - b
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + c ≤ b + (a - b) + c
tactic: rw [tsub_le_iff_left, add_right_comm]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + c ≤ b + (a - b) + c
state_after: no goals
tactic: exact add_le_add_right le_add_tsub c
Theorem: ZMod.cast_descFactorial
File: Mathlib/Data/ZMod/Factorial.lean

Proof steps:
state_before: n p : ℕ
h : n ≤ p
⊢ ↑((p - 1).descFactorial n) = (-1) ^ n * ↑n !
state_after: n p : ℕ
h : n ≤ p
⊢ ↑(∏ i ∈ range n, (p - 1 - i)) = (-1) ^ n * ↑(∏ x ∈ range n, (x + 1))
tactic: rw [descFactorial_eq_prod_range, ← prod_range_add_one_eq_factorial]
state_before: n p : ℕ
h : n ≤ p
⊢ ↑(∏ i ∈ range n, (p - 1 - i)) = (-1) ^ n * ↑(∏ x ∈ range n, (x + 1))
state_after: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ n * ∏ i ∈ range n, ↑(i + 1)
tactic: simp only [cast_prod]
state_before: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ n * ∏ i ∈ range n, ↑(i + 1)
state_after: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ (range n).card * ∏ i ∈ range n, ↑(i + 1)
tactic: nth_rw 2 [← card_range n]
state_before: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ (range n).card * ∏ i ∈ range n, ↑(i + 1)
state_after: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = ∏ a ∈ range n, -1 * ↑(a + 1)
tactic: rw [pow_card_mul_prod]
state_before: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = ∏ a ∈ range n, -1 * ↑(a + 1)
state_after: n p : ℕ
h : n ≤ p
⊢ ∀ x ∈ range n, ↑(p - 1 - x) = -1 * ↑(x + 1)
tactic: refine prod_congr rfl ?_
state_before: n p : ℕ
h : n ≤ p
⊢ ∀ x ∈ range n, ↑(p - 1 - x) = -1 * ↑(x + 1)
state_after: n p : ℕ
h : n ≤ p
x : ℕ
hx : x ∈ range n
⊢ ↑(p - 1 - x) = -1 * ↑(x + 1)
tactic: intro x hx
state_before: n p : ℕ
h : n ≤ p
x : ℕ
hx : x ∈ range n
⊢ ↑(p - 1 - x) = -1 * ↑(x + 1)
state_after: no goals
tactic: rw [← tsub_add_eq_tsub_tsub_swap,
    Nat.cast_sub <| Nat.le_trans (Nat.add_one_le_iff.mpr (List.mem_range.mp hx)) h,
    CharP.cast_eq_zero, zero_sub, cast_succ, neg_add_rev, mul_add, neg_mul, one_mul,
    mul_one, add_comm]
Theorem: TopCat.inducing_pullback_to_prod
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullback f g).topologicalSpace_coe =
    induced (⇑(prod.lift (pullback.fst f g) (pullback.snd f g))) (X ⨯ Y).topologicalSpace_coe
state_after: no goals
tactic: simp [topologicalSpace_coe, prod_topology, pullback_topology, induced_compose, ← coe_comp]
Theorem: List.prod_pos
File: Mathlib/Algebra/Order/BigOperators/Ring/List.lean

Proof steps:
state_before: R : Type u_1
inst✝ : StrictOrderedSemiring R
l : List R
h : ∀ a ∈ l, 0 < a
⊢ 0 < l.prod
state_after: case nil
R : Type u_1
inst✝ : StrictOrderedSemiring R
h : ∀ a ∈ [], 0 < a
⊢ 0 < [].prod

case cons
R : Type u_1
inst✝ : StrictOrderedSemiring R
a : R
l : List R
ih : (∀ a ∈ l, 0 < a) → 0 < l.prod
h : ∀ a_1 ∈ a :: l, 0 < a_1
⊢ 0 < (a :: l).prod
tactic: induction' l with a l ih
Theorem: AlgebraicTopology.DoldKan.QInfty_idem
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ QInfty ≫ QInfty = QInfty
state_after: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ (QInfty ≫ QInfty).f n = QInfty.f n
tactic: ext n
state_before: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ (QInfty ≫ QInfty).f n = QInfty.f n
state_after: no goals
tactic: exact QInfty_f_idem n
Theorem: Associates.prod_le
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
⊢ a.prod ≤ b.prod ↔ a ≤ b
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod ≤ b.prod
⊢ a ≤ b
tactic: refine ⟨fun h ↦ ?_, prod_mono⟩
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod ≤ b.prod
⊢ a ≤ b
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod ≤ b.prod
this : a.prod.factors ≤ b.prod.factors
⊢ a ≤ b
tactic: have : a.prod.factors ≤ b.prod.factors := factors_mono h
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod ≤ b.prod
this : a.prod.factors ≤ b.prod.factors
⊢ a ≤ b
state_after: no goals
tactic: rwa [prod_factors, prod_factors] at this
Theorem: MeasureTheory.MeasurePreserving.comp
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : β → γ
f : α → β
hg : MeasurePreserving g μb μc
hf : MeasurePreserving f μa μb
⊢ map (g ∘ f) μa = μc
state_after: no goals
tactic: rw [← map_map hg.1 hf.1, hf.2, hg.2]