ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: add_sq_le
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
⊢ (a + b) ^ 2 ≤ 2 * (a ^ 2 + b ^ 2)
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
⊢ a * b + b * a ≤ a * a + b * b
tactic: calc
    (a + b) ^ 2 = a ^ 2 + b ^ 2 + (a * b + b * a) := by
        simp_rw [pow_succ', pow_zero, mul_one, add_mul, mul_add, add_comm (b * a), add_add_add_comm]
    _ ≤ a ^ 2 + b ^ 2 + (a * a + b * b) := add_le_add_left ?_ _
    _ = _ := by simp_rw [pow_succ', pow_zero, mul_one, two_mul]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
⊢ a * b + b * a ≤ a * a + b * b
state_after: case inl
α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
h✝ : a ≤ b
⊢ a * b + b * a ≤ a * a + b * b

case inr
α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
h✝ : b ≤ a
⊢ a * b + b * a ≤ a * a + b * b
tactic: cases le_total a b
Theorem: Part.some_union_some
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Union α
a b : α
⊢ some a ∪ some b = some (a ∪ b)
state_after: no goals
tactic: simp [union_def]
Theorem: Zsqrtd.nonnegg_neg_pos
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d✝ : ℤ
c d b : ℕ
⊢ Nonnegg c d (-↑0) ↑b → SqLe 0 d b c
state_after: no goals
tactic: simp [SqLe, Nat.zero_le]
state_before: d✝ : ℤ
c d a b : ℕ
⊢ Nonnegg c d (-↑(a + 1)) ↑b ↔ SqLe (a + 1) d b c
state_after: d✝ : ℤ
c d a b : ℕ
⊢ Nonnegg c d (Int.negSucc a) ↑b ↔ SqLe (a + 1) d b c
tactic: rw [← Int.negSucc_coe]
state_before: d✝ : ℤ
c d a b : ℕ
⊢ Nonnegg c d (Int.negSucc a) ↑b ↔ SqLe (a + 1) d b c
state_after: no goals
tactic: rfl
Theorem: Polynomial.natDegree_multiset_prod_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
⊢ ∀ (a : List R[X]), (prod ⟦a⟧).natDegree ≤ (Multiset.map natDegree ⟦a⟧).sum
state_after: no goals
tactic: simpa using natDegree_list_prod_le
Theorem: Nat.mem_properDivisors_iff_exists
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n✝ m n : ℕ
hn : n ≠ 0
⊢ m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k
state_after: case refine_1
n✝ m n : ℕ
hn : n ≠ 0
h : m ∈ n.properDivisors
⊢ n = m * (n / m)

case refine_2
n✝ m n : ℕ
hn : n ≠ 0
⊢ (∃ k > 1, n = m * k) → m ∈ n.properDivisors
tactic: refine ⟨fun h ↦ ⟨n / m, one_lt_div_of_mem_properDivisors h, ?_⟩, ?_⟩
Theorem: Con.mapOfSurjective_eq_mapGen
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ c.mapGen f = c.mapOfSurjective f H h hf
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ c.mapGen f = conGen ⇑(c.mapOfSurjective f H h hf)
tactic: rw [← conGen_of_con (c.mapOfSurjective f H h hf)]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ c.mapGen f = conGen ⇑(c.mapOfSurjective f H h hf)
state_after: no goals
tactic: rfl
Theorem: NumberField.InfinitePlace.not_isComplex_iff_isReal
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
w : InfinitePlace K
⊢ ¬w.IsComplex ↔ w.IsReal
state_after: no goals
tactic: rw [isComplex_iff, isReal_iff, not_not]
Theorem: Int.ceil_add_le
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌈a + b⌉ ≤ ⌈a⌉ + ⌈b⌉
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ a + b ≤ ↑⌈a⌉ + ↑⌈b⌉
tactic: rw [ceil_le, Int.cast_add]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ a + b ≤ ↑⌈a⌉ + ↑⌈b⌉
state_after: no goals
tactic: exact add_le_add (le_ceil _) (le_ceil _)
Theorem: Finset.odd_sum_iff_odd_card_odd
File: Mathlib/Algebra/BigOperators/Ring/Nat.lean

Proof steps:
state_before: ι : Type u_1
s : Finset ι
f : ι → ℕ
⊢ Odd (∑ i ∈ s, f i) ↔ Odd (filter (fun x => Odd (f x)) s).card
state_after: no goals
tactic: simp only [Nat.odd_iff_not_even, even_sum_iff_even_card_odd]
Theorem: Polynomial.degreeLT_succ_eq_degreeLE
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
⊢ degreeLT R (n + 1) = degreeLE R ↑n
state_after: case h
R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
x : R[X]
⊢ x ∈ degreeLT R (n + 1) ↔ x ∈ degreeLE R ↑n
tactic: ext x
state_before: case h
R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
x : R[X]
⊢ x ∈ degreeLT R (n + 1) ↔ x ∈ degreeLE R ↑n
state_after: case pos
R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
x : R[X]
x_zero : x = 0
⊢ x ∈ degreeLT R (n + 1) ↔ x ∈ degreeLE R ↑n

case neg
R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
x : R[X]
x_zero : ¬x = 0
⊢ x ∈ degreeLT R (n + 1) ↔ x ∈ degreeLE R ↑n
tactic: by_cases x_zero : x = 0
Theorem: Real.rpow_def_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z x : ℝ
hx : 0 < x
y : ℝ
⊢ x ^ y = rexp (log x * y)
state_after: no goals
tactic: rw [rpow_def_of_nonneg (le_of_lt hx), if_neg (ne_of_gt hx)]
Theorem: PythagoreanTriple.mul_iff
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
⊢ PythagoreanTriple (k * x) (k * y) (k * z) ↔ PythagoreanTriple x y z
state_after: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
⊢ PythagoreanTriple (k * x) (k * y) (k * z) → PythagoreanTriple x y z
tactic: refine ⟨?_, fun h => h.mul k⟩
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
⊢ PythagoreanTriple (k * x) (k * y) (k * z) → PythagoreanTriple x y z
state_after: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
⊢ k * x * (k * x) + k * y * (k * y) = k * z * (k * z) → x * x + y * y = z * z
tactic: simp only [PythagoreanTriple]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
⊢ k * x * (k * x) + k * y * (k * y) = k * z * (k * z) → x * x + y * y = z * z
state_after: x y z : ℤ
h✝ : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
h : k * x * (k * x) + k * y * (k * y) = k * z * (k * z)
⊢ x * x + y * y = z * z
tactic: intro h
state_before: x y z : ℤ
h✝ : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
h : k * x * (k * x) + k * y * (k * y) = k * z * (k * z)
⊢ x * x + y * y = z * z
state_after: x y z : ℤ
h✝ : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
h : k * x * (k * x) + k * y * (k * y) = k * z * (k * z)
⊢ (x * x + y * y) * (k * k) = z * z * (k * k)
tactic: rw [← mul_left_inj' (mul_ne_zero hk hk)]
state_before: x y z : ℤ
h✝ : PythagoreanTriple x y z
k : ℤ
hk : k ≠ 0
h : k * x * (k * x) + k * y * (k * y) = k * z * (k * z)
⊢ (x * x + y * y) * (k * k) = z * z * (k * k)
state_after: no goals
tactic: convert h using 1 <;> ring
Theorem: FreeMonoid.countP_of
File: Mathlib/Algebra/FreeMonoid/Count.lean

Proof steps:
state_before: α : Type u_1
p : α → Prop
inst✝ : DecidablePred p
x : α
⊢ (countP p) (of x) = if p x then Multiplicative.ofAdd 1 else 1
state_after: no goals
tactic: rw [countP_of', ofAdd_zero]
Theorem: ENNReal.ofReal_lt_iff_lt_toReal
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
b : ℝ≥0∞
ha : 0 ≤ a
hb : b ≠ ⊤
⊢ ENNReal.ofReal a < b ↔ a < b.toReal
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
ha : 0 ≤ a
b : ℝ≥0
⊢ ENNReal.ofReal a < ↑b ↔ a < (↑b).toReal
tactic: lift b to ℝ≥0 using hb
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
ha : 0 ≤ a
b : ℝ≥0
⊢ ENNReal.ofReal a < ↑b ↔ a < (↑b).toReal
state_after: no goals
tactic: simpa [ENNReal.ofReal, ENNReal.toReal] using Real.toNNReal_lt_iff_lt_coe ha
Theorem: Submonoid.orderOf_le_card
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Submonoid G
hs : (↑s).Finite
hx : x ∈ s
⊢ orderOf x ≤ Nat.card ↥s
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Submonoid G
hs : (↑s).Finite
hx : x ∈ s
⊢ Nat.card ↥(powers x) ≤ Nat.card ↥s
tactic: rw [← Nat.card_submonoidPowers]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Submonoid G
hs : (↑s).Finite
hx : x ∈ s
⊢ Nat.card ↥(powers x) ≤ Nat.card ↥s
state_after: no goals
tactic: exact Nat.card_mono hs <| powers_le.2 hx
Theorem: LinearMap.aeval_self_charpoly
File: Mathlib/LinearAlgebra/Charpoly/Basic.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
f : M →ₗ[R] M
⊢ (aeval f) f.charpoly = 0
state_after: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
f : M →ₗ[R] M
⊢ (algEquivMatrix (chooseBasis R M)).toLinearEquiv ((aeval f) f.charpoly) = 0
tactic: apply (LinearEquiv.map_eq_zero_iff (algEquivMatrix (chooseBasis R M)).toLinearEquiv).1
state_before: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
f : M →ₗ[R] M
⊢ (algEquivMatrix (chooseBasis R M)).toLinearEquiv ((aeval f) f.charpoly) = 0
state_after: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
f : M →ₗ[R] M
⊢ (aeval (↑(algEquivMatrix (chooseBasis R M)) f)) ((toMatrix (chooseBasis R M) (chooseBasis R M)) f).charpoly = 0
tactic: rw [AlgEquiv.toLinearEquiv_apply, ← AlgEquiv.coe_algHom, ← Polynomial.aeval_algHom_apply _ _ _,
    charpoly_def]
state_before: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
f : M →ₗ[R] M
⊢ (aeval (↑(algEquivMatrix (chooseBasis R M)) f)) ((toMatrix (chooseBasis R M) (chooseBasis R M)) f).charpoly = 0
state_after: no goals
tactic: exact Matrix.aeval_self_charpoly _
Theorem: Finset.prod_insert_of_eq_one_if_not_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : a ∉ s → f a = 1
⊢ ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x
state_after: case pos
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : a ∉ s → f a = 1
hm : a ∈ s
⊢ ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x

case neg
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : a ∉ s → f a = 1
hm : a ∉ s
⊢ ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x
tactic: by_cases hm : a ∈ s
Theorem: SimpleGraph.TripartiteFromTriangles.rel_symm
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x✝ : α × β × γ
ε : 𝕜
x y : α ⊕ β ⊕ γ
h : Rel t x y
⊢ Rel t y x
state_after: no goals
tactic: cases h <;> constructor <;> assumption
Theorem: Function.Periodic.comp_addHom
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Add α
inst✝ : Add γ
h : Periodic f c
g : AddHom γ α
g_inv : α → γ
hg : RightInverse g_inv ⇑g
x : γ
⊢ (f ∘ ⇑g) (x + g_inv c) = (f ∘ ⇑g) x
state_after: no goals
tactic: simp only [hg c, h (g x), map_add, comp_apply]
Theorem: Nat.card_zmultiples
File: Mathlib/Data/ZMod/Quotient.lean

Proof steps:
state_before: n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
⊢ Nat.card ↥(zpowers a) = orderOf a
state_after: n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
this : Nat.card ↑(MulAction.orbit (↥(zpowers a)) 1) = Nat.card (ZMod (Function.minimalPeriod (fun x => a • x) 1))
⊢ Nat.card ↥(zpowers a) = orderOf a
tactic: have := Nat.card_congr (MulAction.orbitZPowersEquiv a (1 : α))
state_before: n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
this : Nat.card ↑(MulAction.orbit (↥(zpowers a)) 1) = Nat.card (ZMod (Function.minimalPeriod (fun x => a • x) 1))
⊢ Nat.card ↥(zpowers a) = orderOf a
state_after: no goals
tactic: rwa [Nat.card_zmod, orbit_subgroup_one_eq_self] at this
Theorem: sSupHom.apply_blimsup_le
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ g (blimsup u f p) ≤ blimsup (⇑g ∘ u) f p
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ g (⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), u b) ≤ ⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), g (u b)
tactic: simp only [blimsup_eq_iInf_biSup, Function.comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ g (⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), u b) ≤ ⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), g (u b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ ⨅ i ∈ f, g (⨆ b, ⨆ (_ : p b ∧ b ∈ i), u b) ≤ ⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), g (u b)
tactic: refine ((OrderHomClass.mono g).map_iInf₂_le _).trans ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ ⨅ i ∈ f, g (⨆ b, ⨆ (_ : p b ∧ b ∈ i), u b) ≤ ⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), g (u b)
state_after: no goals
tactic: simp only [_root_.map_iSup, le_refl]
Theorem: MeasureTheory.setToFun_smul
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
hT : DominatedFinMeasAdditive μ T C
h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x
c : 𝕜
f : α → E
⊢ setToFun μ T hT (c • f) = c • setToFun μ T hT f
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
hT : DominatedFinMeasAdditive μ T C
h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x
c : 𝕜
f : α → E
hf : Integrable f μ
⊢ setToFun μ T hT (c • f) = c • setToFun μ T hT f

case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
hT : DominatedFinMeasAdditive μ T C
h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x
c : 𝕜
f : α → E
hf : ¬Integrable f μ
⊢ setToFun μ T hT (c • f) = c • setToFun μ T hT f
tactic: by_cases hf : Integrable f μ
Theorem: Real.summable_exp_nat_mul_iff
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: α : Type u_1
x y z : ℝ
l : Filter α
a : ℝ
⊢ (Summable fun n => rexp (↑n * a)) ↔ a < 0
state_after: no goals
tactic: simp only [exp_nat_mul, summable_geometric_iff_norm_lt_one, norm_of_nonneg (exp_nonneg _),
    exp_lt_one_iff]
Theorem: add_div_eq_mul_add_div
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionSemiring α
a✝ b✝ c d a b : α
hc : c ≠ 0
⊢ (a + b / c) * c = a * c + b
state_after: no goals
tactic: rw [right_distrib, div_mul_cancel₀ _ hc]
Theorem: ciSup_neg
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
p : Prop
f : p → α
hp : ¬p
⊢ ⨆ (h : p), f h = sSup ∅
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
p : Prop
f : p → α
hp : ¬p
⊢ sSup (range fun h => f h) = sSup ∅
tactic: rw [iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
p : Prop
f : p → α
hp : ¬p
⊢ sSup (range fun h => f h) = sSup ∅
state_after: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
p : Prop
f : p → α
hp : ¬p
⊢ (range fun h => f h) = ∅
tactic: congr
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLattice α
s t : Set α
a b : α
p : Prop
f : p → α
hp : ¬p
⊢ (range fun h => f h) = ∅
state_after: no goals
tactic: rwa [range_eq_empty_iff, isEmpty_Prop]
Theorem: Finset.mulDysonETransform_idem
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.1 ∪ e • x.2 ∪ e • (x.2 ∩ e⁻¹ • x.1) = x.1 ∪ e • x.2

case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.2 ∩ e⁻¹ • x.1 ∩ e⁻¹ • (x.1 ∪ e • x.2) = x.2 ∩ e⁻¹ • x.1
tactic: ext : 1 <;> dsimp
Theorem: CategoryTheory.Limits.Types.pi_lift_π_apply'
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

Proof steps:
state_before: β : Type v
f : β → Type v
P : Type v
s : (b : β) → P ⟶ f b
b : β
x : P
⊢ Pi.π f b (Pi.lift s x) = s b x
state_after: no goals
tactic: simp
Theorem: Polynomial.nextCoeff_eq_zero
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✝ : Semiring R
p : R[X]
⊢ p.nextCoeff = 0 ↔ p.natDegree = 0 ∨ 0 < p.natDegree ∧ p.coeff (p.natDegree - 1) = 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p : R[X]
⊢ ¬p.natDegree = 0 → p.coeff (p.natDegree - 1) = 0 ↔ ¬p.natDegree = 0 → ¬p.natDegree = 0 ∧ p.coeff (p.natDegree - 1) = 0
tactic: simp [nextCoeff, or_iff_not_imp_left, pos_iff_ne_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p : R[X]
⊢ ¬p.natDegree = 0 → p.coeff (p.natDegree - 1) = 0 ↔ ¬p.natDegree = 0 → ¬p.natDegree = 0 ∧ p.coeff (p.natDegree - 1) = 0
state_after: no goals
tactic: aesop
Theorem: CategoryTheory.CosimplicialObject.instCategoryAugmented_id_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Augmented C)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
tactic: dsimp only [Augmented]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
state_after: no goals
tactic: infer_instance
Theorem: IsUnit.map
File: Mathlib/Algebra/Group/Units/Hom.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝⁴ : FunLike F M N
inst✝³ : FunLike G N M
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : MonoidHomClass F M N
f : F
x : M
h : IsUnit x
⊢ IsUnit (f x)
state_after: case intro
F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝⁴ : FunLike F M N
inst✝³ : FunLike G N M
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : MonoidHomClass F M N
f : F
y : Mˣ
⊢ IsUnit (f ↑y)
tactic: rcases h with ⟨y, rfl⟩
state_before: case intro
F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝⁴ : FunLike F M N
inst✝³ : FunLike G N M
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : MonoidHomClass F M N
f : F
y : Mˣ
⊢ IsUnit (f ↑y)
state_after: no goals
tactic: exact (Units.map (f : M →* N) y).isUnit
Theorem: Fintype.eval_image_piFinset
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
a : α
inst✝ : DecidableEq (δ a)
ht : ∀ (b : α), a ≠ b → (t b).Nonempty
⊢ image (fun f => f a) (piFinset t) = t a
state_after: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
a : α
inst✝ : DecidableEq (δ a)
ht : ∀ (b : α), a ≠ b → (t b).Nonempty
x : δ a
h : x ∈ t a
⊢ ∃ a_1 ∈ piFinset t, a_1 a = x
tactic: refine (eval_image_piFinset_subset _ _).antisymm fun x h ↦ mem_image.2 ?_
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
a : α
inst✝ : DecidableEq (δ a)
ht : ∀ (b : α), a ≠ b → (t b).Nonempty
x : δ a
h : x ∈ t a
⊢ ∃ a_1 ∈ piFinset t, a_1 a = x
state_after: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
a : α
inst✝ : DecidableEq (δ a)
x : δ a
h : x ∈ t a
f : (b : α) → a ≠ b → δ b
hf : ∀ (b : α) (a : a ≠ b), f b a ∈ t b
⊢ ∃ a_1 ∈ piFinset t, a_1 a = x
tactic: choose f hf using ht
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
a : α
inst✝ : DecidableEq (δ a)
x : δ a
h : x ∈ t a
f : (b : α) → a ≠ b → δ b
hf : ∀ (b : α) (a : a ≠ b), f b a ∈ t b
⊢ ∃ a_1 ∈ piFinset t, a_1 a = x
state_after: no goals
tactic: exact ⟨fun b ↦ if h : a = b then h ▸ x else f _ h, by aesop, by simp⟩