ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.tsum_indicator_apply_singleton
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s✝ : Set α
a : α
inst✝¹ : Countable α
inst✝ : MeasurableSingletonClass α
μ : Measure α
s : Set α
hs : MeasurableSet s
⊢ ∑' (x : α), s.indicator (fun x => μ {x}) x = (sum fun a => μ {a} • dirac a) s
state_after: no goals
tactic: simp only [Measure.sum_apply _ hs, Measure.smul_apply, smul_eq_mul, Measure.dirac_apply,
        Set.indicator_apply, mul_ite, Pi.one_apply, mul_one, mul_zero]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s✝ : Set α
a : α
inst✝¹ : Countable α
inst✝ : MeasurableSingletonClass α
μ : Measure α
s : Set α
hs : MeasurableSet s
⊢ (sum fun a => μ {a} • dirac a) s = μ s
state_after: no goals
tactic: rw [μ.sum_smul_dirac]
Theorem: Function.LeftInverse.filter_map
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInverse g f
F : Filter α
⊢ map g (map f F) = F
state_after: no goals
tactic: rw [map_map, hfg.comp_eq_id, map_id]
Theorem: Filter.hasBasis_generate
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
U : Set α
⊢ U ∈ generate s ↔ ∃ i, (i.Finite ∧ i ⊆ s) ∧ ⋂₀ i ⊆ U
state_after: no goals
tactic: simp only [mem_generate_iff, exists_prop, and_assoc, and_left_comm]
Theorem: tendsto_nat_ceil_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
⊢ Tendsto (fun x => ⌈x⌉₊) atTop atTop
state_after: α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
x : ℕ
⊢ x ≤ ⌈↑x⌉₊
tactic: refine Nat.ceil_mono.tendsto_atTop_atTop (fun x ↦ ⟨x, ?_⟩)
state_before: α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
x : ℕ
⊢ x ≤ ⌈↑x⌉₊
state_after: no goals
tactic: simp only [Nat.ceil_natCast, le_refl]
Theorem: Complex.zero_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x : ℂ
h : x ≠ 0
⊢ 0 ^ x = 0
state_after: no goals
tactic: simp [cpow_def, *]
Theorem: Cardinal.ord_aleph'_eq_enum_card
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ⊢ ord ∘ aleph' = enumOrd {b | b.card.ord = b}
state_after: ⊢ StrictMono (ord ∘ aleph') ∧
    (∀ (a : Ordinal.{u_1}), (ord ∘ aleph') a ∈ {b | b.card.ord = b}) ∧
      ∀ b ∈ {b | b.card.ord = b}, ∃ a, (ord ∘ aleph') a = b
tactic: rw [← eq_enumOrd _ ord_card_unbounded, range_eq_iff]
state_before: ⊢ StrictMono (ord ∘ aleph') ∧
    (∀ (a : Ordinal.{u_1}), (ord ∘ aleph') a ∈ {b | b.card.ord = b}) ∧
      ∀ b ∈ {b | b.card.ord = b}, ∃ a, (ord ∘ aleph') a = b
state_after: no goals
tactic: exact
    ⟨aleph'_isNormal.strictMono,
      ⟨fun a => by
        dsimp
        rw [card_ord], fun b hb => eq_aleph'_of_eq_card_ord hb⟩⟩
Theorem: Module.Dual.finrank_ker_add_one_of_ne_zero
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
⊢ finrank K ↥(LinearMap.ker f) + 1 = finrank K V₁
state_after: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
⊢ finrank K ↥(LinearMap.range f) = 1
tactic: suffices finrank K (LinearMap.range f) = 1 by
    rw [← (LinearMap.ker f).finrank_quotient_add_finrank, add_comm, add_left_inj,
    f.quotKerEquivRange.finrank_eq, this]
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
⊢ finrank K ↥(LinearMap.range f) = 1
state_after: no goals
tactic: rw [range_eq_top_of_ne_zero hf, finrank_top, finrank_self]
Theorem: Ordnode.Raised.right
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
H : Raised r₁.size r₂.size
⊢ Raised (l.node' x₁ r₁).size (l.node' x₂ r₂).size
state_after: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
H : Raised r₁.size r₂.size
⊢ Raised (l.size + r₁.size + 1) (l.size + r₂.size + 1)
tactic: rw [node', size_node, size_node]
state_before: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
H : Raised r₁.size r₂.size
⊢ Raised (l.size + r₁.size + 1) (l.size + r₂.size + 1)
state_after: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
m : ℕ
H : Raised r₁.size m
⊢ Raised (l.size + r₁.size + 1) (l.size + m + 1)
tactic: generalize size r₂ = m at H ⊢
state_before: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
m : ℕ
H : Raised r₁.size m
⊢ Raised (l.size + r₁.size + 1) (l.size + m + 1)
state_after: case inl
α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
⊢ Raised (l.size + r₁.size + 1) (l.size + r₁.size + 1)

case inr
α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
⊢ Raised (l.size + r₁.size + 1) (l.size + (r₁.size + 1) + 1)
tactic: rcases H with (rfl | rfl)
Theorem: Fin.predAbove_right_monotone
File: Mathlib/Order/Fin/Basic.lean

Proof steps:
state_before: m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
⊢ p.predAbove a ≤ p.predAbove b
state_after: m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
⊢ (if h : p.castSucc < a then a.pred ⋯ else a.castPred ⋯) ≤ if h : p.castSucc < b then b.pred ⋯ else b.castPred ⋯
tactic: dsimp [predAbove]
state_before: m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
⊢ (if h : p.castSucc < a then a.pred ⋯ else a.castPred ⋯) ≤ if h : p.castSucc < b then b.pred ⋯ else b.castPred ⋯
state_after: case pos
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : p.castSucc < a
hb : p.castSucc < b
⊢ a.pred ⋯ ≤ b.pred ⋯

case neg
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : p.castSucc < a
hb : ¬p.castSucc < b
⊢ a.pred ⋯ ≤ b.castPred ⋯

case pos
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬p.castSucc < a
hb : p.castSucc < b
⊢ a.castPred ⋯ ≤ b.pred ⋯

case neg
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬p.castSucc < a
hb : ¬p.castSucc < b
⊢ a.castPred ⋯ ≤ b.castPred ⋯
tactic: split_ifs with ha hb hb
state_before: case pos
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : p.castSucc < a
hb : p.castSucc < b
⊢ a.pred ⋯ ≤ b.pred ⋯

case neg
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : p.castSucc < a
hb : ¬p.castSucc < b
⊢ a.pred ⋯ ≤ b.castPred ⋯

case pos
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬p.castSucc < a
hb : p.castSucc < b
⊢ a.castPred ⋯ ≤ b.pred ⋯

case neg
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬p.castSucc < a
hb : ¬p.castSucc < b
⊢ a.castPred ⋯ ≤ b.castPred ⋯
state_after: case pos
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : p.castSucc < a
hb : p.castSucc < b
⊢ ↑a - 1 ≤ ↑b - 1

case neg
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : p.castSucc < a
hb : ¬p.castSucc < b
⊢ ↑a - 1 ≤ ↑(b.castPred ⋯)

case pos
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬p.castSucc < a
hb : p.castSucc < b
⊢ ↑(a.castPred ⋯) ≤ ↑b - 1

case neg
m n : ℕ
p✝ : Fin (n + 1)
i j p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬p.castSucc < a
hb : ¬p.castSucc < b
⊢ ↑(a.castPred ⋯) ≤ ↑(b.castPred ⋯)
tactic: all_goals simp only [le_iff_val_le_val, coe_pred]
Theorem: adjoin_le_integralClosure
File: Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : R →+* S
x : A
hx : IsIntegral R x
⊢ Algebra.adjoin R {x} ≤ integralClosure R A
state_after: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : R →+* S
x : A
hx : IsIntegral R x
⊢ {x} ⊆ ↑(integralClosure R A)
tactic: rw [Algebra.adjoin_le_iff]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : R →+* S
x : A
hx : IsIntegral R x
⊢ {x} ⊆ ↑(integralClosure R A)
state_after: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : R →+* S
x : A
hx : IsIntegral R x
⊢ x ∈ integralClosure R A
tactic: simp only [SetLike.mem_coe, Set.singleton_subset_iff]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : R →+* S
x : A
hx : IsIntegral R x
⊢ x ∈ integralClosure R A
state_after: no goals
tactic: exact hx
Theorem: _private.Mathlib.Combinatorics.Additive.Corner.Roth.0.Corners.noAccidental
File: Mathlib/Combinatorics/Additive/Corner/Roth.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a✝ b✝ c✝ d x y : G
n : ℕ
ε : ℝ
hs : IsCornerFree ↑A
a a' b b' c c' : G
ha : (a', b, c) ∈ Corners.triangleIndices A
hb : (a, b', c) ∈ Corners.triangleIndices A
hc : (a, b, c') ∈ Corners.triangleIndices A
⊢ a = a' ∨ b = b' ∨ c = c'
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a✝ b✝ c✝ d x y : G
n : ℕ
ε : ℝ
hs : IsCornerFree ↑A
a a' b b' c c' : G
ha : (a', b) ∈ A ∧ c = a' + b
hb : (a, b') ∈ A ∧ c = a + b'
hc : (a, b) ∈ A ∧ c' = a + b
⊢ a = a' ∨ b = b' ∨ c = c'
tactic: simp only [mk_mem_triangleIndices] at ha hb hc
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a✝ b✝ c✝ d x y : G
n : ℕ
ε : ℝ
hs : IsCornerFree ↑A
a a' b b' c c' : G
ha : (a', b) ∈ A ∧ c = a' + b
hb : (a, b') ∈ A ∧ c = a + b'
hc : (a, b) ∈ A ∧ c' = a + b
⊢ a = a' ∨ b = b' ∨ c = c'
state_after: no goals
tactic: exact .inl $ hs ⟨hc.1, hb.1, ha.1, hb.2.symm.trans ha.2⟩
Theorem: CategoryTheory.Sieve.mem_ofArrows_iff
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ Z : C
f✝ : Y✝ ⟶ X✝
S R : Sieve X✝
I : Type u_1
X : C
Y : I → C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
⊢ (ofArrows Y f).arrows g ↔ ∃ i a, g = a ≫ f i
state_after: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ Z : C
f✝ : Y✝ ⟶ X✝
S R : Sieve X✝
I : Type u_1
X : C
Y : I → C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
⊢ (ofArrows Y f).arrows g → ∃ i a, g = a ≫ f i

case mpr
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ Z : C
f✝ : Y✝ ⟶ X✝
S R : Sieve X✝
I : Type u_1
X : C
Y : I → C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
⊢ (∃ i a, g = a ≫ f i) → (ofArrows Y f).arrows g
tactic: constructor
Theorem: Submodule.le_comap_pow_of_le_comap
File: Mathlib/Algebra/Module/Submodule/Map.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
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p' : Submodule R M
q q' : Submodule R₂ M₂
x : M
σ₂₁ : R₂ →+* R
inst✝³ : RingHomInvPair σ₁₂ σ₂₁
inst✝² : RingHomInvPair σ₂₁ σ₁₂
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
p : Submodule R M
f : M →ₗ[R] M
h : p ≤ comap f p
k : ℕ
⊢ p ≤ comap (f ^ k) p
state_after: case zero
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
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p' : Submodule R M
q q' : Submodule R₂ M₂
x : M
σ₂₁ : R₂ →+* R
inst✝³ : RingHomInvPair σ₁₂ σ₂₁
inst✝² : RingHomInvPair σ₂₁ σ₁₂
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
p : Submodule R M
f : M →ₗ[R] M
h : p ≤ comap f p
⊢ p ≤ comap (f ^ 0) p

case succ
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
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p✝ p' : Submodule R M
q q' : Submodule R₂ M₂
x : M
σ₂₁ : R₂ →+* R
inst✝³ : RingHomInvPair σ₁₂ σ₂₁
inst✝² : RingHomInvPair σ₂₁ σ₁₂
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
p : Submodule R M
f : M →ₗ[R] M
h : p ≤ comap f p
k : ℕ
ih : p ≤ comap (f ^ k) p
⊢ p ≤ comap (f ^ (k + 1)) p
tactic: induction' k with k ih
Theorem: AddConstMap.coe_addLeftHom_apply
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : AddMonoid G
a : G
⊢ (fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id) 1 = 1
state_after: case h
G : Type u_1
inst✝ : AddMonoid G
a x✝ : G
⊢ ((fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id) 1) x✝ = 1 x✝
tactic: ext
state_before: case h
G : Type u_1
inst✝ : AddMonoid G
a x✝ : G
⊢ ((fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id) 1) x✝ = 1 x✝
state_after: no goals
tactic: apply zero_add
state_before: G : Type u_1
inst✝ : AddMonoid G
a : G
x✝¹ x✝ : Multiplicative G
⊢ { toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun (x✝¹ * x✝) =
    { toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun x✝¹ *
      { toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun x✝
state_after: case h
G : Type u_1
inst✝ : AddMonoid G
a : G
x✝² x✝¹ : Multiplicative G
x✝ : G
⊢ ({ toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun (x✝² * x✝¹)) x✝ =
    ({ toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun x✝² *
        { toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun x✝¹)
      x✝
tactic: ext
state_before: case h
G : Type u_1
inst✝ : AddMonoid G
a : G
x✝² x✝¹ : Multiplicative G
x✝ : G
⊢ ({ toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun (x✝² * x✝¹)) x✝ =
    ({ toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun x✝² *
        { toFun := fun c => Multiplicative.toAdd c +ᵥ AddConstMap.id, map_one' := ⋯ }.toFun x✝¹)
      x✝
state_after: no goals
tactic: apply add_assoc
Theorem: odd_iff_exists_bit1
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b✝ : α
m n : ℕ
b : α
⊢ a = 2 * b + 1 ↔ a = 2 * b + 1
state_after: no goals
tactic: rw [two_mul]
Theorem: Algebra.Generators.CotangentSpace.map_tmul
File: Mathlib/RingTheory/Kaehler/CotangentComplex.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
x : S
y : P.Ring
⊢ (CotangentSpace.map f) (x ⊗ₜ[P.Ring] (D R P.Ring) y) = (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) (f.toAlgHom y)
state_after: R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
x : S
y : P.Ring
⊢ x • 1 ⊗ₜ[P'.Ring] (D R' P'.Ring) ((algebraMap P.Ring P'.Ring) y) =
    (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) (f.toAlgHom y)
tactic: simp only [CotangentSpace.map, AlgHom.toRingHom_eq_coe, LinearMap.liftBaseChange_tmul,
    LinearMap.coe_comp, LinearMap.coe_restrictScalars, Function.comp_apply, map_D, mk_apply]
state_before: R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
x : S
y : P.Ring
⊢ x • 1 ⊗ₜ[P'.Ring] (D R' P'.Ring) ((algebraMap P.Ring P'.Ring) y) =
    (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) (f.toAlgHom y)
state_after: R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
x : S
y : P.Ring
⊢ (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) ((algebraMap P.Ring P'.Ring) y) =
    (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) (f.toAlgHom y)
tactic: rw [smul_tmul', ← Algebra.algebraMap_eq_smul_one]
state_before: R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
x : S
y : P.Ring
⊢ (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) ((algebraMap P.Ring P'.Ring) y) =
    (algebraMap S S') x ⊗ₜ[P'.Ring] (D R' P'.Ring) (f.toAlgHom y)
state_after: no goals
tactic: rfl
Theorem: Polynomial.evalEval_C
File: Mathlib/Algebra/Polynomial/Bivariate.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝ : Semiring R
x y : R
p : R[X]
⊢ evalEval x y (C p) = eval x p
state_after: no goals
tactic: rw [evalEval, eval_C]
Theorem: List.prod_le_prod'
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✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : List ι
f g : ι → M
h : ∀ i ∈ l, f i ≤ g i
⊢ Forall₂ (fun x x_1 => x ≤ x_1) (map f l) (map g l)
state_after: no goals
tactic: simpa
Theorem: div_mul_mul_cancel
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a / c * (b * c) = a * b
state_after: no goals
tactic: rw [mul_left_comm, div_mul_cancel, mul_comm]
Theorem: Absorbs.add
File: Mathlib/Topology/Bornology/Absorbs.lean

Proof steps:
state_before: M : Type u_1
E : Type u_2
inst✝² : Bornology M
s₁ s₂ t₁ t₂ : Set E
inst✝¹ : AddZeroClass E
inst✝ : DistribSMul M E
h₁ : Absorbs M s₁ t₁
h₂ : Absorbs M s₂ t₂
x : M
hx₁ : t₁ ⊆ x • s₁
hx₂ : t₂ ⊆ x • s₂
⊢ t₁ + t₂ ⊆ x • (s₁ + s₂)
state_after: M : Type u_1
E : Type u_2
inst✝² : Bornology M
s₁ s₂ t₁ t₂ : Set E
inst✝¹ : AddZeroClass E
inst✝ : DistribSMul M E
h₁ : Absorbs M s₁ t₁
h₂ : Absorbs M s₂ t₂
x : M
hx₁ : t₁ ⊆ x • s₁
hx₂ : t₂ ⊆ x • s₂
⊢ t₁ + t₂ ⊆ x • s₁ + x • s₂
tactic: rw [smul_add]
state_before: M : Type u_1
E : Type u_2
inst✝² : Bornology M
s₁ s₂ t₁ t₂ : Set E
inst✝¹ : AddZeroClass E
inst✝ : DistribSMul M E
h₁ : Absorbs M s₁ t₁
h₂ : Absorbs M s₂ t₂
x : M
hx₁ : t₁ ⊆ x • s₁
hx₂ : t₂ ⊆ x • s₂
⊢ t₁ + t₂ ⊆ x • s₁ + x • s₂
state_after: no goals
tactic: exact add_subset_add hx₁ hx₂
Theorem: Polynomial.card_support_eraseLead
File: Mathlib/Algebra/Polynomial/EraseLead.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ f.eraseLead.support.card = f.support.card - 1
state_after: case pos
R : Type u_1
inst✝ : Semiring R
f : R[X]
hf : f = 0
⊢ f.eraseLead.support.card = f.support.card - 1

case neg
R : Type u_1
inst✝ : Semiring R
f : R[X]
hf : ¬f = 0
⊢ f.eraseLead.support.card = f.support.card - 1
tactic: by_cases hf : f = 0
Theorem: Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors'
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
t : R
n : ℕ
h : p ≠ 0
hroot : ∀ m ≤ n, ((⇑derivative)^[m] p).IsRoot t
hnzd : ∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ n < rootMultiplicity t p
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
t : R
n : ℕ
h : p ≠ 0
hroot : ∀ m ≤ n, ((⇑derivative)^[m] p).IsRoot t
hnzd : ∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ ↑n.factorial ∈ nonZeroDivisors R
tactic: apply lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors h hroot
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
t : R
n : ℕ
h : p ≠ 0
hroot : ∀ m ≤ n, ((⇑derivative)^[m] p).IsRoot t
hnzd : ∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ ↑n.factorial ∈ nonZeroDivisors R
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
t : R
n : ℕ
h : p ≠ 0
hnzd : ∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ ↑n.factorial ∈ nonZeroDivisors R
tactic: clear hroot
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
t : R
n : ℕ
h : p ≠ 0
hnzd : ∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ ↑n.factorial ∈ nonZeroDivisors R
state_after: case zero
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
hnzd : ∀ m ≤ 0, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ ↑(Nat.factorial 0) ∈ nonZeroDivisors R

case succ
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
n : ℕ
ih : (∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R) → ↑n.factorial ∈ nonZeroDivisors R
hnzd : ∀ m ≤ n + 1, m ≠ 0 → ↑m ∈ nonZeroDivisors R
⊢ ↑(n + 1).factorial ∈ nonZeroDivisors R
tactic: induction' n with n ih
Theorem: WittVector.init_add_tail
File: Mathlib/RingTheory/WittVector/InitTail.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
x : 𝕎 R
n : ℕ
⊢ init n x + tail n x = x
state_after: no goals
tactic: simp only [init, tail, ← not_lt, select_add_select_not]
Theorem: AddMonoidHomClass.antilipschitz_of_bound
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝¹ : FunLike 𝓕 E F
inst✝ : MonoidHomClass 𝓕 E F
f : 𝓕
K : ℝ≥0
h : ∀ (x : E), ‖x‖ ≤ ↑K * ‖f x‖
x y : E
⊢ dist x y ≤ ↑K * dist (f x) (f y)
state_after: no goals
tactic: simpa only [dist_eq_norm_div, map_div] using h (x / y)