ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.integrable_approxOn
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
hf : Integrable f μ
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
hi₀ : Integrable (fun x => y₀) μ
n : ℕ
⊢ Integrable (↑(approxOn f fmeas s y₀ h₀ n)) μ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
hf : Memℒp f 1 μ
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
hi₀ : Memℒp (fun x => y₀) 1 μ
n : ℕ
⊢ Memℒp (↑(approxOn f fmeas s y₀ h₀ n)) 1 μ
tactic: rw [← memℒp_one_iff_integrable] at hf hi₀ ⊢
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
hf : Memℒp f 1 μ
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
hi₀ : Memℒp (fun x => y₀) 1 μ
n : ℕ
⊢ Memℒp (↑(approxOn f fmeas s y₀ h₀ n)) 1 μ
state_after: no goals
tactic: exact memℒp_approxOn fmeas hf h₀ hi₀ n
Theorem: SimpleGraph.Hom.comap_apply
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G₁ G₂ : SimpleGraph V
H : SimpleGraph W
f✝ : G✝ →g G'
f : V → W
G : SimpleGraph W
⊢ ∀ {a b : V}, (SimpleGraph.comap f G).Adj a b → G.Adj (f a) (f b)
state_after: no goals
tactic: simp
Theorem: Complex.cos_antiperiodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Function.Antiperiodic cos ↑π
state_after: no goals
tactic: simp [cos_add]
Theorem: segment_same
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s : Set E
x✝¹ y z✝ x z : E
x✝ : z ∈ [x-[𝕜]x]
a b : 𝕜
left✝¹ : 0 ≤ a
left✝ : 0 ≤ b
hab : a + b = 1
hz : a • x + b • x = z
⊢ z ∈ {x}
state_after: no goals
tactic: simpa only [(add_smul _ _ _).symm, mem_singleton_iff, hab, one_smul, eq_comm] using hz
Theorem: List.takeD_nil
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: α : Type u_1
n : Nat
a : α
⊢ takeD n [] a = replicate n a
state_after: no goals
tactic: induction n <;> simp [*, replicate_succ]
Theorem: Polynomial.Separable.of_mul_right
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (f * g).Separable
⊢ g.Separable
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (g * f).Separable
⊢ g.Separable
tactic: rw [mul_comm] at h
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (g * f).Separable
⊢ g.Separable
state_after: no goals
tactic: exact h.of_mul_left
Theorem: IsGroupHom.trivial_ker_iff_eq_one
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
⊢ ker f = IsSubgroup.trivial G ↔ ∀ (x : G), f x = 1 → x = 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
⊢ (∀ (x : G), x ∈ ker f ↔ x ∈ IsSubgroup.trivial G) ↔ ∀ (x : G), f x = 1 → x = 1
tactic: rw [Set.ext_iff]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
⊢ (∀ (x : G), x ∈ ker f ↔ x ∈ IsSubgroup.trivial G) ↔ ∀ (x : G), f x = 1 → x = 1
state_after: no goals
tactic: simpa [ker] using ⟨fun h x hx => (h x).1 hx, fun h x => ⟨h x, fun hx => by rw [hx, hf.map_one]⟩⟩
Theorem: Finsupp.linearIndependent_single
File: Mathlib/LinearAlgebra/FinsuppVectorSpace.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
ι : Type u_3
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
φ : ι → Type u_4
f : (ι : ι) → φ ι → M
hf : ∀ (i : ι), LinearIndependent R (f i)
⊢ LinearIndependent R fun ix => single ix.fst (f ix.fst ix.snd)
state_after: case hindep
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
φ : ι → Type u_4
f : (ι : ι) → φ ι → M
hf : ∀ (i : ι), LinearIndependent R (f i)
⊢ ∀ (j : ι), LinearIndependent R fun x => single j (f j x)

case hd
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
φ : ι → Type u_4
f : (ι : ι) → φ ι → M
hf : ∀ (i : ι), LinearIndependent R (f i)
⊢ ∀ (i : ι) (t : Set ι),
    t.Finite →
      i ∉ t →
        Disjoint (span R (Set.range fun x => single i (f i x))) (⨆ i ∈ t, span R (Set.range fun x => single i (f i x)))
tactic: apply @linearIndependent_iUnion_finite R _ _ _ _ ι φ fun i x => single i (f i x)
Theorem: PowerSeries.rescale_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝ : CommRing A
a : A
⊢ (rescale a) X = (C A) a * X
state_after: case h
R : Type u_1
A : Type u_2
inst✝ : CommRing A
a : A
n✝ : ℕ
⊢ (coeff A n✝) ((rescale a) X) = (coeff A n✝) ((C A) a * X)
tactic: ext
state_before: case h
R : Type u_1
A : Type u_2
inst✝ : CommRing A
a : A
n✝ : ℕ
⊢ (coeff A n✝) ((rescale a) X) = (coeff A n✝) ((C A) a * X)
state_after: case h
R : Type u_1
A : Type u_2
inst✝ : CommRing A
a : A
n✝ : ℕ
⊢ (a ^ n✝ * if n✝ = 1 then 1 else 0) = a * if n✝ = 1 then 1 else 0
tactic: simp only [coeff_rescale, coeff_C_mul, coeff_X]
state_before: case h
R : Type u_1
A : Type u_2
inst✝ : CommRing A
a : A
n✝ : ℕ
⊢ (a ^ n✝ * if n✝ = 1 then 1 else 0) = a * if n✝ = 1 then 1 else 0
state_after: no goals
tactic: split_ifs with h <;> simp [h]
Theorem: LinearIndependent.cardinal_lift_le_rank
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type w
v : ι → M
hv : LinearIndependent R v
⊢ lift.{v, w} #ι ≤ lift.{w, v} (Module.rank R M)
state_after: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type w
v : ι → M
hv : LinearIndependent R v
⊢ lift.{v, w} #ι ≤ lift.{w, v} (⨆ ι, #↑↑ι)
tactic: rw [Module.rank]
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type w
v : ι → M
hv : LinearIndependent R v
⊢ lift.{v, w} #ι ≤ lift.{w, v} (⨆ ι, #↑↑ι)
state_after: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type w
v : ι → M
hv : LinearIndependent R v
⊢ lift.{v, w} #ι ≤ lift.{w, v} #↑↑⟨range v, ⋯⟩
tactic: refine le_trans ?_ (lift_le.mpr <| le_ciSup (bddAbove_range.{v, v} _) ⟨_, hv.coe_range⟩)
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type w
v : ι → M
hv : LinearIndependent R v
⊢ lift.{v, w} #ι ≤ lift.{w, v} #↑↑⟨range v, ⋯⟩
state_after: no goals
tactic: exact lift_mk_le'.mpr ⟨(Equiv.ofInjective _ hv.injective).toEmbedding⟩
Theorem: Orientation.oangle_sign_sub_left_eq_neg
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ (o.oangle (y - x) y).sign = -(o.oangle x y).sign
state_after: no goals
tactic: rw [← o.oangle_sign_smul_sub_left x y 1, one_smul]
Theorem: DFA.toNFA_evalFrom_match
File: Mathlib/Computability/NFA.lean

Proof steps:
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ M.toNFA.evalFrom {start} s = {M.evalFrom start s}
state_after: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
tactic: change List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
s : List α
⊢ List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
state_after: case nil
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
start : σ
⊢ List.foldl M.toNFA.stepSet {start} [] = {List.foldl M.step start []}

case cons
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
a : α
s : List α
ih : ∀ (start : σ), List.foldl M.toNFA.stepSet {start} s = {List.foldl M.step start s}
start : σ
⊢ List.foldl M.toNFA.stepSet {start} (a :: s) = {List.foldl M.step start (a :: s)}
tactic: induction' s with a s ih generalizing start
Theorem: Int.log_of_right_le_zero
File: Mathlib/Data/Int/Log.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 0
⊢ log b r = 0
state_after: no goals
tactic: rw [log_of_right_le_one _ (hr.trans zero_le_one),
    Nat.clog_of_right_le_one ((Nat.ceil_eq_zero.mpr <| inv_nonpos.2 hr).trans_le zero_le_one),
    Int.ofNat_zero, neg_zero]
Theorem: Subtype.surjective_restrict
File: Mathlib/Data/Subtype.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
⊢ Surjective fun f => restrict p f
state_after: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
⊢ Surjective fun f => restrict p f
tactic: letI := Classical.decPred p
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
⊢ Surjective fun f => restrict p f
state_after: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
f : (x : Subtype p) → β ↑x
⊢ ∀ (x : Subtype p), (fun f => restrict p f) (fun x => if h : p x then f ⟨x, h⟩ else ⋯.some) x = f x
tactic: refine fun f ↦ ⟨fun x ↦ if h : p x then f ⟨x, h⟩ else Nonempty.some (ne x), funext <| ?_⟩
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
f : (x : Subtype p) → β ↑x
⊢ ∀ (x : Subtype p), (fun f => restrict p f) (fun x => if h : p x then f ⟨x, h⟩ else ⋯.some) x = f x
state_after: case mk
α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
f : (x : Subtype p) → β ↑x
x : α
hx : p x
⊢ (fun f => restrict p f) (fun x => if h : p x then f ⟨x, h⟩ else ⋯.some) ⟨x, hx⟩ = f ⟨x, hx⟩
tactic: rintro ⟨x, hx⟩
state_before: case mk
α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
f : (x : Subtype p) → β ↑x
x : α
hx : p x
⊢ (fun f => restrict p f) (fun x => if h : p x then f ⟨x, h⟩ else ⋯.some) ⟨x, hx⟩ = f ⟨x, hx⟩
state_after: no goals
tactic: exact dif_pos hx
Theorem: MeasureTheory.withDensity_absolutelyContinuous
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
⊢ μ.withDensity f ≪ μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hs₁ : MeasurableSet s
hs₂ : μ s = 0
⊢ (μ.withDensity f) s = 0
tactic: refine AbsolutelyContinuous.mk fun s hs₁ hs₂ => ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hs₁ : MeasurableSet s
hs₂ : μ s = 0
⊢ (μ.withDensity f) s = 0
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hs₁ : MeasurableSet s
hs₂ : μ s = 0
⊢ ∫⁻ (a : α) in s, f a ∂μ = 0
tactic: rw [withDensity_apply _ hs₁]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hs₁ : MeasurableSet s
hs₂ : μ s = 0
⊢ ∫⁻ (a : α) in s, f a ∂μ = 0
state_after: no goals
tactic: exact setLIntegral_measure_zero _ _ hs₂
Theorem: Finset.sup'_image
File: Mathlib/Data/Finset/Lattice.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✝¹ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
inst✝ : DecidableEq β
s : Finset γ
f : γ → β
hs : (image f s).Nonempty
g : β → α
⊢ (image f s).sup' hs g = s.sup' ⋯ (g ∘ f)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
inst✝ : DecidableEq β
s : Finset γ
f : γ → β
hs : (image f s).Nonempty
g : β → α
⊢ ↑((image f s).sup' hs g) = ↑(s.sup' ⋯ (g ∘ f))
tactic: rw [← WithBot.coe_eq_coe]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
inst✝ : DecidableEq β
s : Finset γ
f : γ → β
hs : (image f s).Nonempty
g : β → α
⊢ ↑((image f s).sup' hs g) = ↑(s.sup' ⋯ (g ∘ f))
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
inst✝ : DecidableEq β
s : Finset γ
f : γ → β
hs : (image f s).Nonempty
g : β → α
⊢ s.sup ((WithBot.some ∘ g) ∘ f) = s.sup (WithBot.some ∘ g ∘ f)
tactic: simp only [coe_sup', sup_image, WithBot.coe_sup]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
inst✝ : DecidableEq β
s : Finset γ
f : γ → β
hs : (image f s).Nonempty
g : β → α
⊢ s.sup ((WithBot.some ∘ g) ∘ f) = s.sup (WithBot.some ∘ g ∘ f)
state_after: no goals
tactic: rfl
Theorem: div_eq_inv_mul
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✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b = b⁻¹ * a
state_after: no goals
tactic: simp
Theorem: HomogeneousIdeal.toIdeal_iInf
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_5
s : κ → HomogeneousIdeal 𝒜
⊢ (⨅ i, s i).toIdeal = ⨅ i, (s i).toIdeal
state_after: no goals
tactic: rw [iInf, toIdeal_sInf, iInf_range]
Theorem: HahnSeries.ofPowerSeries_apply
File: Mathlib/RingTheory/HahnSeries/PowerSeries.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, { toFun := Nat.cast, inj' := ⋯ } a ≤ { toFun := Nat.cast, inj' := ⋯ } b ↔ a ≤ b
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, ↑a ≤ ↑b ↔ a ≤ b
tactic: simp only [Function.Embedding.coeFn_mk]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : StrictOrderedSemiring Γ
x : PowerSeries R
⊢ ∀ {a b : ℕ}, ↑a ≤ ↑b ↔ a ≤ b
state_after: no goals
tactic: exact Nat.cast_le
Theorem: List.get_rotate
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
n : ℕ
k : Fin (l.rotate n).length
⊢ (l.rotate n).get k = l.get ⟨(↑k + n) % l.length, ⋯⟩
state_after: no goals
tactic: simp [getElem_rotate]
Theorem: Int.natAbs_coe_sub_coe_le_of_le
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: a✝ b✝ : ℤ
n✝ a b n : ℕ
a_le_n : a ≤ n
b_le_n : b ≤ n
⊢ (↑a - ↑b).natAbs ≤ n
state_after: a✝ b✝ : ℤ
n✝ a b n : ℕ
a_le_n : a ≤ n
b_le_n : b ≤ n
⊢ |↑a - ↑b| ≤ ↑n
tactic: rw [← Nat.cast_le (α := ℤ), natCast_natAbs]
state_before: a✝ b✝ : ℤ
n✝ a b n : ℕ
a_le_n : a ≤ n
b_le_n : b ≤ n
⊢ |↑a - ↑b| ≤ ↑n
state_after: no goals
tactic: exact abs_sub_le_of_nonneg_of_le (ofNat_nonneg a) (ofNat_le.mpr a_le_n)
    (ofNat_nonneg b) (ofNat_le.mpr b_le_n)
Theorem: Ordinal.nadd_nmul
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a✝ b✝ c✝ d : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c
state_after: no goals
tactic: rw [nmul_comm, nmul_nadd, nmul_comm, nmul_comm c]
Theorem: Nat.coprime_mul_succ
File: Mathlib/Logic/Godel/GodelBetaFunction.lean

Proof steps:
state_before: n m a : ℕ
h : n ≤ m
ha : m - n ∣ a
p : ℕ
pp : Prime p
hn : p ∣ n * a + 1
hm : p ∣ m * a + 1
⊢ False
state_after: n m a : ℕ
h : n ≤ m
ha : m - n ∣ a
p : ℕ
pp : Prime p
hn : p ∣ n * a + 1
hm : p ∣ m * a + 1
this : p ∣ (m - n) * a
⊢ False
tactic: have : p ∣ (m - n) * a := by
      simpa [Nat.succ_sub_succ, ← Nat.mul_sub_right_distrib] using
        Nat.dvd_sub (Nat.succ_le_succ $ Nat.mul_le_mul_right a h) hm hn
state_before: n m a : ℕ
h : n ≤ m
ha : m - n ∣ a
p : ℕ
pp : Prime p
hn : p ∣ n * a + 1
hm : p ∣ m * a + 1
this✝ : p ∣ (m - n) * a
this : p ∣ a
⊢ False
state_after: n m a : ℕ
h : n ≤ m
ha : m - n ∣ a
p : ℕ
pp : Prime p
hn : p ∣ n * a + 1
hm : p ∣ m * a + 1
this✝ : p ∣ (m - n) * a
this : p ∣ a
⊢ p = 1
tactic: apply pp.ne_one
state_before: n m a : ℕ
h : n ≤ m
ha : m - n ∣ a
p : ℕ
pp : Prime p
hn : p ∣ n * a + 1
hm : p ∣ m * a + 1
this✝ : p ∣ (m - n) * a
this : p ∣ a
⊢ p = 1
state_after: no goals
tactic: simpa [Nat.add_sub_cancel_left] using Nat.dvd_sub (le_add_right _ _) hn (this.mul_left n)
Theorem: weightedVSub_mem_vectorSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
⊢ (s.weightedVSub p) w ∈ vectorSpan k {(affineCombination k s p) w₁, (affineCombination k s p) w₂} ↔
    ∃ r, ∀ i ∈ s, w i = r * (w₁ i - w₂ i)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
⊢ (∃ r, r • ((affineCombination k s p) w₁ -ᵥ (affineCombination k s p) w₂) = (s.weightedVSub p) w) ↔
    ∃ r, ∀ i ∈ s, w i = r * (w₁ i - w₂ i)
tactic: rw [mem_vectorSpan_pair]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
⊢ (∃ r, r • ((affineCombination k s p) w₁ -ᵥ (affineCombination k s p) w₂) = (s.weightedVSub p) w) ↔
    ∃ r, ∀ i ∈ s, w i = r * (w₁ i - w₂ i)
state_after: case refine_1
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h✝ : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
h : ∃ r, r • ((affineCombination k s p) w₁ -ᵥ (affineCombination k s p) w₂) = (s.weightedVSub p) w
⊢ ∃ r, ∀ i ∈ s, w i = r * (w₁ i - w₂ i)

case refine_2
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h✝ : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
h : ∃ r, ∀ i ∈ s, w i = r * (w₁ i - w₂ i)
⊢ ∃ r, r • ((affineCombination k s p) w₁ -ᵥ (affineCombination k s p) w₂) = (s.weightedVSub p) w
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: Submodule.tmul_mem_baseChange_of_mem
File: Mathlib/LinearAlgebra/TensorProduct/Tower.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
a : A
m : M
hm : m ∈ p
⊢ a ⊗ₜ[R] m ∈ baseChange A p
state_after: R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
a : A
m : M
hm : m ∈ p
⊢ a • 1 ⊗ₜ[R] m ∈ baseChange A p
tactic: rw [← mul_one a, ← smul_eq_mul, ← smul_tmul']
state_before: R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
a : A
m : M
hm : m ∈ p
⊢ a • 1 ⊗ₜ[R] m ∈ baseChange A p
state_after: no goals
tactic: exact smul_mem (baseChange A p) a (subset_span ⟨m, hm, rfl⟩)
Theorem: Equiv.Perm.card_support_conj
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
⊢ (σ * τ * σ⁻¹).support.card = τ.support.card
state_after: no goals
tactic: simp
Theorem: ComplexShape.Embedding.prev_f_of_not_boundaryGE
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
i j : ι
hij : c.prev j = i
hj : ¬e.BoundaryGE j
⊢ c'.prev (e.f j) = e.f i
state_after: case pos
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
i j : ι
hij : c.prev j = i
hj : ¬e.BoundaryGE j
hij' : c.Rel i j
⊢ c'.prev (e.f j) = e.f i

case neg
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
i j : ι
hij : c.prev j = i
hj : ¬e.BoundaryGE j
hij' : ¬c.Rel i j
⊢ c'.prev (e.f j) = e.f i
tactic: by_cases hij' : c.Rel i j
Theorem: IsLocalization.mk'_zero
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
s : ↥M
⊢ mk' S 0 s = 0
state_after: no goals
tactic: rw [eq_comm, IsLocalization.eq_mk'_iff_mul_eq, zero_mul, map_zero]