ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.sInf_mem
File: Mathlib/Data/Nat/Lattice.lean

Proof steps:
state_before: s : Set ℕ
h : s.Nonempty
⊢ sInf s ∈ s
state_after: s : Set ℕ
h : s.Nonempty
⊢ Nat.find h ∈ s
tactic: rw [Nat.sInf_def h]
state_before: s : Set ℕ
h : s.Nonempty
⊢ Nat.find h ∈ s
state_after: no goals
tactic: exact Nat.find_spec h
Theorem: NNReal.exists_pow_lt_of_lt_one
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: a b : ℝ≥0
ha : 0 < a
hb : b < 1
⊢ ∃ n, b ^ n < a
state_after: no goals
tactic: simpa only [← coe_pow, NNReal.coe_lt_coe] using
    exists_pow_lt_of_lt_one (NNReal.coe_pos.2 ha) (NNReal.coe_lt_coe.2 hb)
Theorem: AlgHom.card_of_powerBasis
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : IsSeparable K pb.gen
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
⊢ Fintype.card (S →ₐ[K] L) = pb.dim
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : IsSeparable K pb.gen
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
x✝ : Fintype (S →ₐ[K] L) := PowerBasis.AlgHom.fintype pb
⊢ Fintype.card (S →ₐ[K] L) = pb.dim
tactic: let _ := (PowerBasis.AlgHom.fintype pb : Fintype (S →ₐ[K] L))
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : IsSeparable K pb.gen
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
x✝ : Fintype (S →ₐ[K] L) := PowerBasis.AlgHom.fintype pb
⊢ Fintype.card (S →ₐ[K] L) = pb.dim
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : IsSeparable K pb.gen
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
x✝ : Fintype (S →ₐ[K] L) := PowerBasis.AlgHom.fintype pb
⊢ ((minpoly K pb.gen).aroots L).Nodup
tactic: rw [Fintype.card_congr pb.liftEquiv', Fintype.card_of_subtype _ (fun x => Multiset.mem_toFinset),
    ← pb.natDegree_minpoly, natDegree_eq_card_roots h_splits, Multiset.toFinset_card_of_nodup]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁵ : CommRing S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : IsSeparable K pb.gen
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
x✝ : Fintype (S →ₐ[K] L) := PowerBasis.AlgHom.fintype pb
⊢ ((minpoly K pb.gen).aroots L).Nodup
state_after: no goals
tactic: exact nodup_roots ((separable_map (algebraMap K L)).mpr h_sep)
Theorem: MeasureTheory.IsStoppingTime.measurableSet_lt_of_countable_range
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : PartialOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | τ ω < i}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : PartialOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i}
⊢ MeasurableSet {ω | τ ω < i}
tactic: have : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i} := by ext1 ω; simp [lt_iff_le_and_ne]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : PartialOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i}
⊢ MeasurableSet {ω | τ ω < i}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : PartialOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i}
⊢ MeasurableSet ({ω | τ ω ≤ i} \ {ω | τ ω = i})
tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : PartialOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i}
⊢ MeasurableSet ({ω | τ ω ≤ i} \ {ω | τ ω = i})
state_after: no goals
tactic: exact (hτ.measurableSet_le i).diff (hτ.measurableSet_eq_of_countable_range h_countable i)
Theorem: ZFSet.toSet_pair
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y : ZFSet
⊢ (x.pair y).toSet = {{x}, {x, y}}
state_after: no goals
tactic: simp [pair]
Theorem: List.IsRotated.trans
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l l' l✝ : List α
n m : ℕ
⊢ l✝.rotate (n + m) = (l✝.rotate n).rotate m
state_after: no goals
tactic: rw [rotate_rotate]
Theorem: Metric.cthickening_eq_iInter_thickening''
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ cthickening δ E = ⋂ ε, ⋂ (_ : max 0 δ < ε), thickening ε E
state_after: case δ_nn
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ 0 ≤ max 0 δ
tactic: rw [← cthickening_max_zero, cthickening_eq_iInter_thickening]
state_before: case δ_nn
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ 0 ≤ max 0 δ
state_after: no goals
tactic: exact le_max_left _ _
Theorem: Algebra.trace_eq_matrix_trace
File: Mathlib/RingTheory/Trace/Defs.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
ι κ : Type w
inst✝¹ : Fintype ι
b✝ : Basis ι R S
inst✝ : DecidableEq ι
b : Basis ι R S
s : S
⊢ (trace R S) s = ((leftMulMatrix b) s).trace
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
ι κ : Type w
inst✝¹ : Fintype ι
b✝ : Basis ι R S
inst✝ : DecidableEq ι
b : Basis ι R S
s : S
⊢ ((toMatrix b b) ((lmul R S) s)).trace = ((toMatrix b b) (mulLeft R s)).trace
tactic: rw [trace_apply, LinearMap.trace_eq_matrix_trace _ b, ← toMatrix_lmul_eq]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
ι κ : Type w
inst✝¹ : Fintype ι
b✝ : Basis ι R S
inst✝ : DecidableEq ι
b : Basis ι R S
s : S
⊢ ((toMatrix b b) ((lmul R S) s)).trace = ((toMatrix b b) (mulLeft R s)).trace
state_after: no goals
tactic: rfl
Theorem: BoxIntegral.Prepartition.splitMany_insert
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
I : Box ι
s : Finset (ι × ℝ)
p : ι × ℝ
⊢ splitMany I (insert p s) = splitMany I s ⊓ split I p.1 p.2
state_after: no goals
tactic: rw [splitMany, Finset.inf_insert, inf_comm, splitMany]
Theorem: ENNReal.exists_nat_pos_mul_gt
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
hb : b ≠ ⊤
n : ℕ
hn : b / a < ↑n
⊢ b < ↑n * a
state_after: no goals
tactic: rwa [← ENNReal.div_lt_iff (Or.inl ha) (Or.inr hb)]
Theorem: EuclideanGeometry.dist_mul_of_eq_angle_of_dist_mul
File: Mathlib/Geometry/Euclidean/Triangle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c a' b' c' : P
r : ℝ
h : ∠ a' b' c' = ∠ a b c
hab : dist a' b' = r * dist a b
hcb : dist c' b' = r * dist c b
⊢ dist a' c' = r * dist a c
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c a' b' c' : P
r : ℝ
h : ∠ a' b' c' = ∠ a b c
hab : dist a' b' = r * dist a b
hcb : dist c' b' = r * dist c b
h' : dist a' c' ^ 2 = (r * dist a c) ^ 2
⊢ dist a' c' = r * dist a c
tactic: have h' : dist a' c' ^ 2 = (r * dist a c) ^ 2 := calc
    dist a' c' ^ 2 =
        dist a' b' ^ 2 + dist c' b' ^ 2 - 2 * dist a' b' * dist c' b' * Real.cos (∠ a' b' c') := by
      simp [pow_two, law_cos a' b' c']
    _ = r ^ 2 * (dist a b ^ 2 + dist c b ^ 2 - 2 * dist a b * dist c b * Real.cos (∠ a b c)) := by
      rw [h, hab, hcb]; ring
    _ = (r * dist a c) ^ 2 := by simp [pow_two, ← law_cos a b c, mul_pow]; ring
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c a' b' c' : P
r : ℝ
h : ∠ a' b' c' = ∠ a b c
hab : dist a' b' = r * dist a b
hcb : dist c' b' = r * dist c b
h' : dist a' c' ^ 2 = (r * dist a c) ^ 2
⊢ dist a' c' = r * dist a c
state_after: case pos
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c a' b' c' : P
r : ℝ
h : ∠ a' b' c' = ∠ a b c
hab : dist a' b' = r * dist a b
hcb : dist c' b' = r * dist c b
h' : dist a' c' ^ 2 = (r * dist a c) ^ 2
hab₁ : a = b
⊢ dist a' c' = r * dist a c

case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c a' b' c' : P
r : ℝ
h : ∠ a' b' c' = ∠ a b c
hab : dist a' b' = r * dist a b
hcb : dist c' b' = r * dist c b
h' : dist a' c' ^ 2 = (r * dist a c) ^ 2
hab₁ : ¬a = b
⊢ dist a' c' = r * dist a c
tactic: by_cases hab₁ : a = b
Theorem: sign_zero
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a : α
⊢ sign 0 = 0
state_after: no goals
tactic: simp [sign_apply]
Theorem: CategoryTheory.Limits.biproduct.isoCoproduct_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ ι f j ≫ (isoCoproduct f).hom = ι f j ≫ desc (Sigma.ι f)
state_after: no goals
tactic: simp [← Iso.eq_comp_inv]
Theorem: MeasureTheory.Measure.measurePreserving_div_left
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : DivisionMonoid G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
μ✝ μ : Measure G
inst✝¹ : μ.IsInvInvariant
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ MeasurePreserving (fun t => g / t) μ μ
state_after: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : DivisionMonoid G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
μ✝ μ : Measure G
inst✝¹ : μ.IsInvInvariant
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ MeasurePreserving (fun t => g * t⁻¹) μ μ
tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : DivisionMonoid G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
μ✝ μ : Measure G
inst✝¹ : μ.IsInvInvariant
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ MeasurePreserving (fun t => g * t⁻¹) μ μ
state_after: no goals
tactic: exact (measurePreserving_mul_left μ g).comp (measurePreserving_inv μ)
Theorem: ChainComplex.truncate_obj_X
File: Mathlib/Algebra/Homology/Augment.lean

Proof steps:
state_before: V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i j : ℕ
w : ¬(ComplexShape.down ℕ).Rel i j
⊢ ¬(ComplexShape.down ℕ).Rel (i + 1) (j + 1)
state_after: no goals
tactic: simpa
Theorem: AddTorsor.connectedSpace
File: Mathlib/Topology/Algebra/MulAction.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝⁵ : AddGroup G
inst✝⁴ : AddTorsor G P
inst✝³ : TopologicalSpace G
inst✝² : PreconnectedSpace G
inst✝¹ : TopologicalSpace P
inst✝ : ContinuousVAdd G P
⊢ IsPreconnected Set.univ
state_after: case h.e'_3
G : Type u_1
P : Type u_2
inst✝⁵ : AddGroup G
inst✝⁴ : AddTorsor G P
inst✝³ : TopologicalSpace G
inst✝² : PreconnectedSpace G
inst✝¹ : TopologicalSpace P
inst✝ : ContinuousVAdd G P
⊢ Set.univ = ⇑(Equiv.vaddConst (Classical.arbitrary P)) '' Set.univ
tactic: convert
        isPreconnected_univ.image (Equiv.vaddConst (Classical.arbitrary P) : G → P)
          (continuous_id.vadd continuous_const).continuousOn
state_before: case h.e'_3
G : Type u_1
P : Type u_2
inst✝⁵ : AddGroup G
inst✝⁴ : AddTorsor G P
inst✝³ : TopologicalSpace G
inst✝² : PreconnectedSpace G
inst✝¹ : TopologicalSpace P
inst✝ : ContinuousVAdd G P
⊢ Set.univ = ⇑(Equiv.vaddConst (Classical.arbitrary P)) '' Set.univ
state_after: no goals
tactic: rw [Set.image_univ, Equiv.range_eq_univ]
Theorem: balancedHull.balanced
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
⊢ Balanced 𝕜 (balancedHull 𝕜 s)
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ a • balancedHull 𝕜 s ⊆ balancedHull 𝕜 s
tactic: intro a ha
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ a • balancedHull 𝕜 s ⊆ balancedHull 𝕜 s
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ ∀ (x : E), (∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ a • i • s) → ∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ i • s
tactic: simp_rw [balancedHull, smul_set_iUnion₂, subset_def, mem_iUnion₂]
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ ∀ (x : E), (∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ a • i • s) → ∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ i • s
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
x : E
r : 𝕜
hr : ‖r‖ ≤ 1
hx : x ∈ a • r • s
⊢ ∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ i • s
tactic: rintro x ⟨r, hr, hx⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
x : E
r : 𝕜
hr : ‖r‖ ≤ 1
hx : x ∈ a • r • s
⊢ ∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ i • s
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
x : E
r : 𝕜
hr : ‖r‖ ≤ 1
hx : x ∈ (a • r) • s
⊢ ∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ i • s
tactic: rw [← smul_assoc] at hx
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
x : E
r : 𝕜
hr : ‖r‖ ≤ 1
hx : x ∈ (a • r) • s
⊢ ∃ i, ∃ (_ : ‖i‖ ≤ 1), x ∈ i • s
state_after: no goals
tactic: exact ⟨a • r, (SeminormedRing.norm_mul _ _).trans (mul_le_one ha (norm_nonneg r) hr), hx⟩
Theorem: ProbabilityTheory.poissonPMFRealSum
File: Mathlib/Probability/Distributions/Poisson.lean

Proof steps:
state_before: r : ℝ≥0
⊢ HasSum (fun n => poissonPMFReal r n) 1
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => poissonPMFReal r✝ n) 1
tactic: let r := r.toReal
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => poissonPMFReal r✝ n) 1
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => rexp (-↑r✝) * ↑r✝ ^ n / ↑n !) 1
tactic: unfold poissonPMFReal
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun n => rexp (-↑r✝) * ↑r✝ ^ n / ↑n !) 1
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r * 1)
tactic: apply (hasSum_mul_left_iff (exp_ne_zero r)).mp
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r * 1)
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)
tactic: simp only [mul_one]
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)
tactic: have : (fun i ↦ rexp r * (rexp (-r) * r ^ i / ↑(Nat.factorial i))) =
      fun i ↦ r ^ i / ↑(Nat.factorial i) := by
    ext n
    rw [mul_div_assoc, exp_neg, ← mul_assoc, ← div_eq_mul_inv, div_self (exp_ne_zero r), one_mul]
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => rexp r * (rexp (-↑r✝) * ↑r✝ ^ i / ↑i !)) (rexp r)
state_after: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => r ^ i / ↑i !) (NormedSpace.exp ℝ r)
tactic: rw [this, exp_eq_exp_ℝ]
state_before: r✝ : ℝ≥0
r : ℝ := ↑r✝
this : (fun i => rexp r * (rexp (-r) * r ^ i / ↑i !)) = fun i => r ^ i / ↑i !
⊢ HasSum (fun i => r ^ i / ↑i !) (NormedSpace.exp ℝ r)
state_after: no goals
tactic: exact NormedSpace.expSeries_div_hasSum_exp ℝ r
Theorem: List.formPerm_eq_head_iff_eq_getLast
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
⊢ (y :: l).formPerm x = y ↔ (y :: l).formPerm x = (y :: l).formPerm ((y :: l).getLast ⋯)
state_after: no goals
tactic: rw [formPerm_apply_getLast]
Theorem: Cardinal.aleph0_lt_lift
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{u}
⊢ ℵ₀ < lift.{v, u} c ↔ ℵ₀ < c
state_after: no goals
tactic: rw [← lift_aleph0.{v, u}, lift_lt]
Theorem: BoxIntegral.Prepartition.mem_split_iff
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
⊢ J ∈ split I i x ↔ ↑J = I.splitLower i x ∨ ↑J = I.splitUpper i x
state_after: no goals
tactic: simp [split]
Theorem: Dioph.diophFn_vec_comp1
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ v ∈ {v | f v ::ₒ v ∈ {v | (v ∘ none :: some) ∈ S}} ↔ v ∈ {v | (f v :: v) ∈ S}
state_after: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) ∈ S ↔ v ∈ {v | (f v :: v) ∈ S}
tactic: dsimp
state_before: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) ∈ S ↔ v ∈ {v | (f v :: v) ∈ S}
state_after: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) = f v :: v
tactic: refine iff_of_eq (congrFun (congrArg Membership.mem ?_) S)
state_before: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) = f v :: v
state_after: case h
α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
x : Fin2 (n + 1)
⊢ ((f v ::ₒ v) ∘ none :: some) x = (f v :: v) x
tactic: ext x
state_before: case h
α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
x : Fin2 (n + 1)
⊢ ((f v ::ₒ v) ∘ none :: some) x = (f v :: v) x
state_after: no goals
tactic: cases x <;> rfl
Theorem: String.Iterator.ValidFor.nextn
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
x✝ : 0 ≤ r.length
⊢ ValidFor ((List.take 0 r).reverse ++ l) (List.drop 0 r) (it.nextn 0)
state_after: no goals
tactic: simp [h, Iterator.nextn]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
n : Nat
hn : n + 1 ≤ r.length
⊢ ValidFor ((List.take (n + 1) r).reverse ++ l) (List.drop (n + 1) r) (it.nextn (n + 1))
state_after: l r : List Char
it : Iterator
h : ValidFor l r it
n : Nat
hn : n + 1 ≤ r.length
⊢ ValidFor ((List.take (n + 1) r).reverse ++ l) (List.drop (n + 1) r) (it.next.nextn n)
tactic: simp only [Iterator.nextn]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
n : Nat
hn : n + 1 ≤ r.length
⊢ ValidFor ((List.take (n + 1) r).reverse ++ l) (List.drop (n + 1) r) (it.next.nextn n)
state_after: l r✝ : List Char
it : Iterator
n : Nat
a : Char
r : List Char
h : ValidFor l (a :: r) it
hn : n + 1 ≤ (a :: r).length
⊢ ValidFor ((List.take (n + 1) (a :: r)).reverse ++ l) (List.drop (n + 1) (a :: r)) (it.next.nextn n)
tactic: have a::r := r
state_before: l r✝ : List Char
it : Iterator
n : Nat
a : Char
r : List Char
h : ValidFor l (a :: r) it
hn : n + 1 ≤ (a :: r).length
⊢ ValidFor ((List.take (n + 1) (a :: r)).reverse ++ l) (List.drop (n + 1) (a :: r)) (it.next.nextn n)
state_after: no goals
tactic: simpa using h.next.nextn _ (Nat.le_of_succ_le_succ hn)
Theorem: IsBaseChange.lift_eq
File: Mathlib/RingTheory/IsTensorProduct.lean

Proof steps:
state_before: R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S
inst✝¹⁰ : Algebra R S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module S N
inst✝⁶ : IsScalarTower R S N
f : M →ₗ[R] N
h : IsBaseChange S f
P : Type u_2
Q : Type u_3
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
inst✝³ : AddCommMonoid Q
inst✝² : Module S Q
inst✝¹ : Module R Q
inst✝ : IsScalarTower R S Q
g : M →ₗ[R] Q
x : M
⊢ (h.lift g) (f x) = g x
state_after: R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S
inst✝¹⁰ : Algebra R S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module S N
inst✝⁶ : IsScalarTower R S N
f : M →ₗ[R] N
h : IsBaseChange S f
P : Type u_2
Q : Type u_3
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
inst✝³ : AddCommMonoid Q
inst✝² : Module S Q
inst✝¹ : Module R Q
inst✝ : IsScalarTower R S Q
g : M →ₗ[R] Q
x : M
hF : ∀ (s : S) (m : M), (h.lift g) (s • f m) = s • g m
⊢ (h.lift g) (f x) = g x
tactic: have hF : ∀ (s : S) (m : M), h.lift g (s • f m) = s • g m := h.lift_eq _
state_before: R : Type u_1
M : Type v₁
N : Type v₂
S : Type v₃
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : AddCommMonoid N
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S
inst✝¹⁰ : Algebra R S
inst✝⁹ : Module R M
inst✝⁸ : Module R N
inst✝⁷ : Module S N
inst✝⁶ : IsScalarTower R S N
f : M →ₗ[R] N
h : IsBaseChange S f
P : Type u_2
Q : Type u_3
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
inst✝³ : AddCommMonoid Q
inst✝² : Module S Q
inst✝¹ : Module R Q
inst✝ : IsScalarTower R S Q
g : M →ₗ[R] Q
x : M
hF : ∀ (s : S) (m : M), (h.lift g) (s • f m) = s • g m
⊢ (h.lift g) (f x) = g x
state_after: no goals
tactic: convert hF 1 x <;> rw [one_smul]
Theorem: Equiv.permCongr_refl
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
α' : Type u_1
β' : Type u_2
e : α' ≃ β'
⊢ e.permCongr (Equiv.refl α') = Equiv.refl β'
state_after: no goals
tactic: simp [permCongr_def]