ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.sum_extend_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β
ι : Type u_8
ι' : Type u_9
f : ι → ι'
hf : Injective f
m : ι → Measure α
⊢ sum (Function.extend f m 0) = sum m
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β
ι : Type u_8
ι' : Type u_9
f : ι → ι'
hf : Injective f
m : ι → Measure α
s : Set α
hs : MeasurableSet s
⊢ (sum (Function.extend f m 0)) s = (sum m) s
tactic: ext s hs
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β
ι : Type u_8
ι' : Type u_9
f : ι → ι'
hf : Injective f
m : ι → Measure α
s : Set α
hs : MeasurableSet s
⊢ (sum (Function.extend f m 0)) s = (sum m) s
state_after: no goals
tactic: simp [*, Function.apply_extend (fun μ : Measure α ↦ μ s)]
Theorem: Basis.sumCoords_self_apply
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ b.sumCoords (b i) = 1
state_after: no goals
tactic: simp only [Basis.sumCoords, LinearMap.id_coe, LinearEquiv.coe_coe, id, Basis.repr_self,
    Function.comp_apply, Finsupp.coe_lsum, LinearMap.coe_comp, Finsupp.sum_single_index]
Theorem: List.takeWhile_eq_nil_iff
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p l = [] ↔ ∀ (hl : 0 < l.length), ¬p (l.nthLe 0 hl) = true
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p [] = [] ↔ ∀ (hl : 0 < [].length), ¬p ([].nthLe 0 hl) = true

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x : α
xs : List α
IH : takeWhile p xs = [] ↔ ∀ (hl : 0 < xs.length), ¬p (xs.nthLe 0 hl) = true
⊢ takeWhile p (x :: xs) = [] ↔ ∀ (hl : 0 < (x :: xs).length), ¬p ((x :: xs).nthLe 0 hl) = true
tactic: induction' l with x xs IH
Theorem: List.Ico.inter_consecutive
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
⊢ Ico n m ∩ Ico m l = []
state_after: n m l : ℕ
⊢ ∀ (a : ℕ), a ∉ Ico n m ∩ Ico m l
tactic: apply eq_nil_iff_forall_not_mem.2
state_before: n m l : ℕ
⊢ ∀ (a : ℕ), a ∉ Ico n m ∩ Ico m l
state_after: n m l a : ℕ
⊢ a ∉ Ico n m ∩ Ico m l
tactic: intro a
state_before: n m l a : ℕ
⊢ a ∉ Ico n m ∩ Ico m l
state_after: n m l a : ℕ
⊢ n ≤ a → a < m → m ≤ a → l ≤ a
tactic: simp only [and_imp, not_and, not_lt, List.mem_inter_iff, List.Ico.mem]
state_before: n m l a : ℕ
⊢ n ≤ a → a < m → m ≤ a → l ≤ a
state_after: n m l a : ℕ
a✝ : n ≤ a
h₂ : a < m
h₃ : m ≤ a
⊢ l ≤ a
tactic: intro _ h₂ h₃
state_before: n m l a : ℕ
a✝ : n ≤ a
h₂ : a < m
h₃ : m ≤ a
⊢ l ≤ a
state_after: n m l a : ℕ
a✝ : n ≤ a
h₂ : a < m
h₃ : m ≤ a
⊢ False
tactic: exfalso
state_before: n m l a : ℕ
a✝ : n ≤ a
h₂ : a < m
h₃ : m ≤ a
⊢ False
state_after: no goals
tactic: exact not_lt_of_ge h₃ h₂
Theorem: Computation.map_think
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ map f (think ⟨s, al⟩) = (map f ⟨s, al⟩).think
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ ↑(map f (think ⟨s, al⟩)) = ↑(map f ⟨s, al⟩).think
tactic: apply Subtype.eq
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ ↑(map f (think ⟨s, al⟩)) = ↑(map f ⟨s, al⟩).think
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some (f val)) o) (Stream'.cons none s) =
    Stream'.cons none (Stream'.map (fun o => Option.rec none (fun val => some (f val)) o) s)
tactic: dsimp [think, map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some (f val)) o) (Stream'.cons none s) =
    Stream'.cons none (Stream'.map (fun o => Option.rec none (fun val => some (f val)) o) s)
state_after: no goals
tactic: rw [Stream'.map_cons]
Theorem: AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec_preimage_basicOpen
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
t : NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ ⇑(toSpec 𝒜 f).val.base ⁻¹' ↑(sbo HomogeneousLocalization.mk t) =
    ↑((Opens.comap { toFun := Subtype.val, continuous_toFun := ⋯ }) (pbo ↑t.num))
state_after: case h.e'_2.h.e'_3
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
t : NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ ⇑(toSpec 𝒜 f).val.base = ProjIsoSpecTopComponent.ToSpec.toFun f
tactic: convert (ProjIsoSpecTopComponent.ToSpec.preimage_basicOpen f t)
state_before: case h.e'_2.h.e'_3
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
t : NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ ⇑(toSpec 𝒜 f).val.base = ProjIsoSpecTopComponent.ToSpec.toFun f
state_after: no goals
tactic: exact funext fun _ => toSpec_base_apply_eq _ _
Theorem: Computable.map_decode_iff
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Computable₂ fun a n => Option.map (f a) (decode n)) ↔ Computable₂ f
state_after: case h.e'_1.h.e'_7.h.h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
x✝¹ : α
x✝ : ℕ
⊢ Option.map (f x✝¹) (decode x✝) = (decode x✝).bind (Option.some ∘ f x✝¹)
tactic: convert (bind_decode_iff (f := fun a => Option.some ∘ f a)).trans option_some_iff
state_before: case h.e'_1.h.e'_7.h.h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
x✝¹ : α
x✝ : ℕ
⊢ Option.map (f x✝¹) (decode x✝) = (decode x✝).bind (Option.some ∘ f x✝¹)
state_after: no goals
tactic: apply Option.map_eq_bind
Theorem: SimpleGraph.Subgraph.coe_deleteEdges_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
⊢ (G'.deleteEdges s).coe ≤ G'.coe
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
v w : ↑(G'.deleteEdges s).verts
⊢ (G'.deleteEdges s).coe.Adj v w → G'.coe.Adj v w
tactic: intro v w
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
v w : ↑(G'.deleteEdges s).verts
⊢ (G'.deleteEdges s).coe.Adj v w → G'.coe.Adj v w
state_after: no goals
tactic: simp (config := { contextual := true })
Theorem: ZFSet.IsTransitive.sUnion'
File: Mathlib/SetTheory/ZFC/Ordinal.lean

Proof steps:
state_before: x y✝ z✝ : ZFSet
H : ∀ y ∈ x, y.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
⊢ z ∈ ⋃₀ x
state_after: case intro.intro
x y✝ z✝ : ZFSet
H : ∀ y ∈ x, y.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x
tactic: rcases mem_sUnion.1 hy with ⟨w, hw, hw'⟩
state_before: case intro.intro
x y✝ z✝ : ZFSet
H : ∀ y ∈ x, y.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x
state_after: no goals
tactic: exact mem_sUnion_of_mem ((H w hw).mem_trans hz hw') hw
Theorem: eq_sub_of_add_eq
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✝ : Group G
a b c d : G
n : ℤ
h : a * c = b
⊢ a = b / c
state_after: no goals
tactic: simp [← h]
Theorem: Function.Injective.preimage_surjective
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
⊢ Surjective (preimage f)
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
⊢ ∃ a, f ⁻¹' a = s
tactic: intro s
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
⊢ ∃ a, f ⁻¹' a = s
state_after: case h
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
⊢ f ⁻¹' (f '' s) = s
tactic: use f '' s
state_before: case h
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
⊢ f ⁻¹' (f '' s) = s
state_after: no goals
tactic: rw [hf.preimage_image]
Theorem: pow_mul_pow_sub
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✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
h : m ≤ n
⊢ a ^ m * a ^ (n - m) = a ^ n
state_after: no goals
tactic: rw [← pow_add, Nat.add_comm, Nat.sub_add_cancel h]
Theorem: MeasureTheory.Integrable.norm_integral_condDistrib_map
File: Mathlib/Probability/Kernel/CondDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ Integrable (fun x => ‖∫ (y : Ω), f (x, y) ∂(condDistrib Y X μ) x‖) (Measure.map X μ)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ Integrable (fun x => ‖∫ (y : Ω), f (x, y) ∂(Measure.map (fun a => (X a, Y a)) μ).condKernel x‖)
    (Measure.map (fun a => (X a, Y a)) μ).fst
tactic: rw [condDistrib, ← Measure.fst_map_prod_mk₀ (X := X) hY]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ Integrable (fun x => ‖∫ (y : Ω), f (x, y) ∂(Measure.map (fun a => (X a, Y a)) μ).condKernel x‖)
    (Measure.map (fun a => (X a, Y a)) μ).fst
state_after: no goals
tactic: exact hf_int.norm_integral_condKernel
Theorem: Real.exp_strictMono
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
h : x < y
⊢ rexp x < rexp y
state_after: x✝ y✝ x y : ℝ
h : x < y
⊢ rexp x < rexp (y - x) * rexp x
tactic: rw [← sub_add_cancel y x, Real.exp_add]
state_before: x✝ y✝ x y : ℝ
h : x < y
⊢ rexp x < rexp (y - x) * rexp x
state_after: no goals
tactic: exact (lt_mul_iff_one_lt_left (exp_pos _)).2
      (lt_of_lt_of_le (by linarith) (add_one_le_exp_of_nonneg (by linarith)))
Theorem: Cycle.forall_eq_of_chain
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : Chain r s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b
state_after: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : ∀ a ∈ s, ∀ b ∈ s, r a b
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b
tactic: rw [chain_iff_pairwise] at hs
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : ∀ a ∈ s, ∀ b ∈ s, r a b
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b
state_after: no goals
tactic: exact antisymm (hs a ha b hb) (hs b hb a ha)
Theorem: Filter.tendsto_finset_image_atTop_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : DecidableEq β
i : β → γ
j : γ → β
h : Function.LeftInverse j i
a : β
⊢ a ∈ Finset.image j {i a}
state_after: no goals
tactic: simp only [Finset.image_singleton, h a, Finset.mem_singleton]
Theorem: List.mem_mem_ranges_iff_lt_natSum
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
l : List ℕ
n : ℕ
⊢ (∃ s ∈ l.ranges, n ∈ s) ↔ n < Nat.sum l
state_after: no goals
tactic: rw [← mem_range, ← ranges_join', mem_join]
Theorem: map_iInf
File: Mathlib/Order/Hom/CompleteLattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ι : Sort u_6
κ : ι → Sort u_7
inst✝³ : FunLike F α β
inst✝² : InfSet α
inst✝¹ : InfSet β
inst✝ : sInfHomClass F α β
f : F
g : ι → α
⊢ f (⨅ i, g i) = ⨅ i, f (g i)
state_after: no goals
tactic: simp [iInf, ← Set.range_comp, Function.comp]
Theorem: WeierstrassCurve.Φ_one
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.Φ 1 = X
state_after: no goals
tactic: erw [Φ_ofNat, preΨ'_one, one_pow, mul_one, mul_one, preΨ'_zero, mul_zero, zero_mul, sub_zero]
Theorem: Finpartition.mk_mem_sparsePairs
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε✝ δ : 𝕜
u✝ v✝ u v : Finset α
ε : 𝕜
⊢ (u, v) ∈ P.sparsePairs G ε ↔ u ∈ P.parts ∧ v ∈ P.parts ∧ u ≠ v ∧ ↑(G.edgeDensity u v) < ε
state_after: no goals
tactic: rw [sparsePairs, mem_filter, mem_offDiag, and_assoc, and_assoc]
Theorem: Complex.reCLM_norm
File: Mathlib/Analysis/Complex/OperatorNorm.lean

Proof steps:
state_before: ⊢ 1 = ‖reCLM 1‖
state_after: no goals
tactic: simp
state_before: ⊢ ‖1‖ ≤ 1
state_after: no goals
tactic: simp
Theorem: sup_left_right_swap
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c : α
⊢ a ⊔ b ⊔ c = c ⊔ b ⊔ a
state_after: no goals
tactic: rw [sup_comm, sup_comm a, sup_assoc]
Theorem: Submodule.mul_toAddSubmonoid
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ (M * N).toAddSubmonoid = M.toAddSubmonoid * N.toAddSubmonoid
state_after: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ (map₂ (LinearMap.mul R A) M N).toAddSubmonoid = ⨆ s, AddSubmonoid.map (AddMonoidHom.mulLeft ↑s) N.toAddSubmonoid
tactic: dsimp [HMul.hMul, Mul.mul]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ (map₂ (LinearMap.mul R A) M N).toAddSubmonoid = ⨆ s, AddSubmonoid.map (AddMonoidHom.mulLeft ↑s) N.toAddSubmonoid
state_after: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ ⨆ i, (map ((LinearMap.mul R A) ↑i) N).toAddSubmonoid =
    ⨆ s, AddSubmonoid.map (AddMonoidHom.mulLeft ↑s) N.toAddSubmonoid
tactic: rw [map₂, iSup_toAddSubmonoid]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ ⨆ i, (map ((LinearMap.mul R A) ↑i) N).toAddSubmonoid =
    ⨆ s, AddSubmonoid.map (AddMonoidHom.mulLeft ↑s) N.toAddSubmonoid
state_after: no goals
tactic: rfl
Theorem: tendsto_rpow_atBot_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

Proof steps:
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ Tendsto (fun x => b ^ x) atBot atTop
state_after: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ Tendsto (fun x => rexp (log b * x)) atBot atTop
tactic: simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ Tendsto (fun x => rexp (log b * x)) atBot atTop
state_after: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ log b < 0
tactic: refine tendsto_exp_atTop.comp <| (tendsto_const_mul_atTop_iff_neg <| tendsto_id (α := ℝ)).mpr ?_
state_before: b : ℝ
hb₀ : 0 < b
hb₁ : b < 1
⊢ log b < 0
state_after: no goals
tactic: exact (log_neg_iff hb₀).mpr hb₁
Theorem: Set.ncard_le_ncard_of_injOn
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
⊢ s.ncard ≤ t.ncard
state_after: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ s.ncard ≤ t.ncard
tactic: have hle := encard_le_encard_of_injOn hf f_inj
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ s.ncard ≤ t.ncard
state_after: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ ↑s.ncard ≤ ↑t.ncard
tactic: to_encard_tac
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ ↑s.ncard ≤ ↑t.ncard
state_after: no goals
tactic: rwa [ht.cast_ncard_eq, (ht.finite_of_encard_le hle).cast_ncard_eq]
Theorem: quasiIso_iff_of_arrow_mk_iso
File: Mathlib/Algebra/Homology/QuasiIso.lean

Proof steps:
state_before: ι : Type u_1
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : K' ⟶ L'
e : Arrow.mk φ ≅ Arrow.mk φ'
inst✝³ : ∀ (i : ι), K.HasHomology i
inst✝² : ∀ (i : ι), L.HasHomology i
inst✝¹ : ∀ (i : ι), K'.HasHomology i
inst✝ : ∀ (i : ι), L'.HasHomology i
⊢ QuasiIso φ ↔ QuasiIso φ'
state_after: ι : Type u_1
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : K' ⟶ L'
e : Arrow.mk φ ≅ Arrow.mk φ'
inst✝³ : ∀ (i : ι), K.HasHomology i
inst✝² : ∀ (i : ι), L.HasHomology i
inst✝¹ : ∀ (i : ι), K'.HasHomology i
inst✝ : ∀ (i : ι), L'.HasHomology i
⊢ QuasiIso
      ((let_fun this := e.inv.left;
        this) ≫
        φ) ↔
    QuasiIso
      (φ' ≫
        let_fun this := e.inv.right;
        this)
tactic: rw [← quasiIso_iff_comp_left (show K' ⟶ K from e.inv.left) φ,
    ← quasiIso_iff_comp_right φ' (show L' ⟶ L from e.inv.right)]
state_before: ι : Type u_1
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : K' ⟶ L'
e : Arrow.mk φ ≅ Arrow.mk φ'
inst✝³ : ∀ (i : ι), K.HasHomology i
inst✝² : ∀ (i : ι), L.HasHomology i
inst✝¹ : ∀ (i : ι), K'.HasHomology i
inst✝ : ∀ (i : ι), L'.HasHomology i
⊢ QuasiIso
      ((let_fun this := e.inv.left;
        this) ≫
        φ) ↔
    QuasiIso
      (φ' ≫
        let_fun this := e.inv.right;
        this)
state_after: ι : Type u_1
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : K' ⟶ L'
e : Arrow.mk φ ≅ Arrow.mk φ'
inst✝³ : ∀ (i : ι), K.HasHomology i
inst✝² : ∀ (i : ι), L.HasHomology i
inst✝¹ : ∀ (i : ι), K'.HasHomology i
inst✝ : ∀ (i : ι), L'.HasHomology i
⊢ QuasiIso ((Arrow.mk φ').hom ≫ e.inv.right) ↔
    QuasiIso
      (φ' ≫
        let_fun this := e.inv.right;
        this)
tactic: erw [Arrow.w e.inv]
state_before: ι : Type u_1
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : K' ⟶ L'
e : Arrow.mk φ ≅ Arrow.mk φ'
inst✝³ : ∀ (i : ι), K.HasHomology i
inst✝² : ∀ (i : ι), L.HasHomology i
inst✝¹ : ∀ (i : ι), K'.HasHomology i
inst✝ : ∀ (i : ι), L'.HasHomology i
⊢ QuasiIso ((Arrow.mk φ').hom ≫ e.inv.right) ↔
    QuasiIso
      (φ' ≫
        let_fun this := e.inv.right;
        this)
state_after: no goals
tactic: rfl
Theorem: LSeries.term_convolution'
File: Mathlib/NumberTheory/LSeries/Convolution.lean

Proof steps:
state_before: f g : ℕ → ℂ
s : ℂ
⊢ term (f ⍟ g) s = fun n => ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2
state_after: case h
f g : ℕ → ℂ
s : ℂ
n : ℕ
⊢ term (f ⍟ g) s n = ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2
tactic: ext n
state_before: case h
f g : ℕ → ℂ
s : ℂ
n : ℕ
⊢ term (f ⍟ g) s n = ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2
state_after: case h.inl
f g : ℕ → ℂ
s : ℂ
⊢ term (f ⍟ g) s 0 = ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {0})), term f s (↑b).1 * term g s (↑b).2

case h.inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ term (f ⍟ g) s n = ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2
tactic: rcases eq_or_ne n 0 with rfl | hn
state_before: case h.inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ term (f ⍟ g) s n = ∑' (b : ↑((fun p => p.1 * p.2) ⁻¹' {n})), term f s (↑b).1 * term g s (↑b).2
state_after: no goals
tactic: rw [show (fun p : ℕ × ℕ ↦ p.1 * p.2) ⁻¹' {n} = n.divisorsAntidiagonal by ext; simp [hn],
    Finset.tsum_subtype' n.divisorsAntidiagonal fun p ↦ term f s p.1 * term g s p.2,
    term_convolution f g s n]