tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.FiniteMeasure.self_eq_mass_smul_normalize
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: apply eq_of_forall_apply_eq
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
⊢ μ = mass μ • ProbabilityMeasure.toFiniteMeasure (normalize μ)

tactic: intro s _s_mble
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
⊢ ∀ (s : Set Ω),
    MeasurableSet s →
      (fun s => ENNReal.toNNReal (↑↑↑μ s)) s =
        (fun s => ENNReal.toNNReal (↑↑↑(mass μ • ProbabilityMeasure.toFiniteMeasure (normalize μ)) s)) s

tactic: rw [μ.self_eq_mass_mul_normalize s, coeFn_smul_apply, smul_eq_mul,
  ProbabilityMeasure.coeFn_comp_toFiniteMeasure_eq_coeFn]
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
_s_mble : MeasurableSet s
⊢ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s =
    (fun s => ENNReal.toNNReal (↑↑↑(mass μ • ProbabilityMeasure.toFiniteMeasure (normalize μ)) s)) s
Theorem: ConvexCone.to_orderedSMul
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: intro x y z xy hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.56571
G : Type ?u.56574
inst✝² : LinearOrderedField 𝕜
inst✝¹ : OrderedAddCommGroup E
inst✝ : Module 𝕜 E
S : ConvexCone 𝕜 E
h : ∀ (x y : E), x ≤ y ↔ y - x ∈ S
⊢ ∀ ⦃a b : E⦄ ⦃c : 𝕜⦄, a < b → 0 < c → c • a ≤ c • b

tactic: rw [h (z • x) (z • y), ← smul_sub z y x]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.56571
G : Type ?u.56574
inst✝² : LinearOrderedField 𝕜
inst✝¹ : OrderedAddCommGroup E
inst✝ : Module 𝕜 E
S : ConvexCone 𝕜 E
h : ∀ (x y : E), x ≤ y ↔ y - x ∈ S
x y : E
z : 𝕜
xy : x < y
hz : 0 < z
⊢ z • x ≤ z • y

tactic: exact smul_mem S hz ((h x y).mp xy.le)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.56571
G : Type ?u.56574
inst✝² : LinearOrderedField 𝕜
inst✝¹ : OrderedAddCommGroup E
inst✝ : Module 𝕜 E
S : ConvexCone 𝕜 E
h : ∀ (x y : E), x ≤ y ↔ y - x ∈ S
x y : E
z : 𝕜
xy : x < y
hz : 0 < z
⊢ z • (y - x) ∈ S
Theorem: Finset.injOn_of_card_image_eq
File: Mathlib/Data/Finset/Card.lean

tactic: rw [card_def, card_def, image, toFinset] at H
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : card (image f s) = card s
⊢ Set.InjOn f ↑s

tactic: dsimp only at H
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H :
  ↑Multiset.card { val := dedup (Multiset.map f s.val), nodup := (_ : Nodup (dedup (Multiset.map f s.val))) }.val =
    ↑Multiset.card s.val
⊢ Set.InjOn f ↑s

tactic: have : (s.1.map f).dedup = s.1.map f := by
  refine Multiset.eq_of_le_of_card_le (Multiset.dedup_le _) ?_
  simp only [H, Multiset.card_map, le_rfl]
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : ↑Multiset.card (dedup (Multiset.map f s.val)) = ↑Multiset.card s.val
⊢ Set.InjOn f ↑s

tactic: rw [Multiset.dedup_eq_self] at this
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : ↑Multiset.card (dedup (Multiset.map f s.val)) = ↑Multiset.card s.val
this : dedup (Multiset.map f s.val) = Multiset.map f s.val
⊢ Set.InjOn f ↑s

tactic: exact inj_on_of_nodup_map this
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : ↑Multiset.card (dedup (Multiset.map f s.val)) = ↑Multiset.card s.val
this : Nodup (Multiset.map f s.val)
⊢ Set.InjOn f ↑s

tactic: refine Multiset.eq_of_le_of_card_le (Multiset.dedup_le _) ?_
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : ↑Multiset.card (dedup (Multiset.map f s.val)) = ↑Multiset.card s.val
⊢ dedup (Multiset.map f s.val) = Multiset.map f s.val

tactic: simp only [H, Multiset.card_map, le_rfl]
state_before: α : Type u_2
β : Type u_1
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq β
H : ↑Multiset.card (dedup (Multiset.map f s.val)) = ↑Multiset.card s.val
⊢ ↑Multiset.card (Multiset.map f s.val) ≤ ↑Multiset.card (dedup (Multiset.map f s.val))
Theorem: NormedSpace.bounded_polar_of_mem_nhds_zero
File: Mathlib/Analysis/NormedSpace/Dual.lean

tactic: obtain ⟨a, ha⟩ : ∃ a : 𝕜, 1 < ‖a‖ := NormedField.exists_one_lt_norm 𝕜
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
s_nhd : s ∈ 𝓝 0
⊢ Metric.Bounded (polar 𝕜 s)

tactic: obtain ⟨r, r_pos, r_ball⟩ : ∃ r : ℝ, 0 < r ∧ ball 0 r ⊆ s := Metric.mem_nhds_iff.1 s_nhd
state_before: case intro
𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
s_nhd : s ∈ 𝓝 0
a : 𝕜
ha : 1 < ‖a‖
⊢ Metric.Bounded (polar 𝕜 s)

tactic: exact
  bounded_closedBall.mono
    (((dualPairing 𝕜 E).flip.polar_antitone r_ball).trans <|
      polar_ball_subset_closedBall_div ha r_pos)
state_before: case intro.intro.intro
𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
s_nhd : s ∈ 𝓝 0
a : 𝕜
ha : 1 < ‖a‖
r : ℝ
r_pos : 0 < r
r_ball : ball 0 r ⊆ s
⊢ Metric.Bounded (polar 𝕜 s)
Theorem: CategoryTheory.MonoidalClosed.uncurry_pre
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

tactic: rw [uncurry_eq, id_tensor_pre_app_comp_ev]
state_before: C : Type u
inst✝³ : Category C
inst✝² : MonoidalCategory C
A B X✝ X' Y Y' Z : C
inst✝¹ : Closed A
inst✝ : Closed B
f : B ⟶ A
X : C
⊢ uncurry ((pre f).app X) = (f ⊗ 𝟙 ((ihom A).obj X)) ≫ (ihom.ev A).app X
Theorem: Module.isTorsionBy_iff_torsionBy_eq_top
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [← torsionBySet_singleton_eq, ← isTorsionBySet_singleton_iff,
  isTorsionBySet_iff_torsionBySet_eq_top]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ IsTorsionBy R M a ↔ torsionBy R M a = ⊤
Theorem: Rat.den_div_cast_eq_one_iff
File: Mathlib/Data/Rat/Lemmas.lean

tactic: replace hn : (n : ℚ) ≠ 0
state_before: m n : ℤ
hn : n ≠ 0
⊢ (↑m / ↑n).den = 1 ↔ n ∣ m

tactic: constructor
state_before: m n : ℤ
hn : ↑n ≠ 0
⊢ (↑m / ↑n).den = 1 ↔ n ∣ m

tactic: rwa [Ne.def, ← Int.cast_zero, coe_int_inj]
state_before: case hn
m n : ℤ
hn : n ≠ 0
⊢ ↑n ≠ 0

tactic: intro h
state_before: case mp
m n : ℤ
hn : ↑n ≠ 0
⊢ (↑m / ↑n).den = 1 → n ∣ m

tactic: use ((m : ℚ) / n).num
state_before: case mp
m n : ℤ
hn : ↑n ≠ 0
h : (↑m / ↑n).den = 1
⊢ n ∣ m

tactic: have hk := Rat.coe_int_num_of_den_eq_one h
state_before: case mp
m n : ℤ
hn : ↑n ≠ 0
h : (↑m / ↑n).den = 1
⊢ m = n * (↑m / ↑n).num

tactic: simp_rw [eq_div_iff_mul_eq hn, ← Int.cast_mul] at hk
state_before: case mp
m n : ℤ
hn : ↑n ≠ 0
h : (↑m / ↑n).den = 1
hk : ↑(↑m / ↑n).num = ↑m / ↑n
⊢ m = n * (↑m / ↑n).num

tactic: rwa [mul_comm, eq_comm, coe_int_inj] at hk
state_before: case mp
m n : ℤ
hn : ↑n ≠ 0
h : (↑m / ↑n).den = 1
hk : ↑((↑m / ↑n).num * n) = ↑m
⊢ m = n * (↑m / ↑n).num

tactic: rintro ⟨d, rfl⟩
state_before: case mpr
m n : ℤ
hn : ↑n ≠ 0
⊢ n ∣ m → (↑m / ↑n).den = 1

tactic: rw [Int.cast_mul, mul_comm, mul_div_cancel _ hn, Rat.coe_int_den]
state_before: case mpr.intro
n : ℤ
hn : ↑n ≠ 0
d : ℤ
⊢ (↑(n * d) / ↑n).den = 1
Theorem: Finset.map_add_right_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_map, coe_Ioo, coe_Ioo]
state_before: ι : Type ?u.229555
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Ioo a b) = Ioo (a + c) (b + c)

tactic: exact Set.image_add_const_Ioo _ _ _
state_before: ι : Type ?u.229555
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ↑(addRightEmbedding c) '' Set.Ioo a b = Set.Ioo (a + c) (b + c)
Theorem: Finsupp.sum_update_add
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [update_eq_erase_add_single, sum_add_index' hg hgg]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285219
ι : Type u_3
M : Type ?u.285225
M' : Type ?u.285228
N : Type ?u.285231
P : Type ?u.285234
G : Type ?u.285237
H : Type ?u.285240
R : Type ?u.285243
S : Type ?u.285246
inst✝² : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝¹ : AddCommMonoid α
inst✝ : AddCommMonoid β
f : ι →₀ α
i : ι
a : α
g : ι → α → β
hg : ∀ (i : ι), g i 0 = 0
hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂
⊢ sum (update f i a) g + g i (↑f i) = sum f g + g i a

tactic: conv_rhs => rw [← Finsupp.update_self f i]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285219
ι : Type u_3
M : Type ?u.285225
M' : Type ?u.285228
N : Type ?u.285231
P : Type ?u.285234
G : Type ?u.285237
H : Type ?u.285240
R : Type ?u.285243
S : Type ?u.285246
inst✝² : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝¹ : AddCommMonoid α
inst✝ : AddCommMonoid β
f : ι →₀ α
i : ι
a : α
g : ι → α → β
hg : ∀ (i : ι), g i 0 = 0
hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂
⊢ ((sum (erase i f) fun a => g a) + sum (single i a) fun a => g a) + g i (↑f i) = sum f g + g i a

tactic: rw [update_eq_erase_add_single, sum_add_index' hg hgg, add_assoc, add_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285219
ι : Type u_3
M : Type ?u.285225
M' : Type ?u.285228
N : Type ?u.285231
P : Type ?u.285234
G : Type ?u.285237
H : Type ?u.285240
R : Type ?u.285243
S : Type ?u.285246
inst✝² : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝¹ : AddCommMonoid α
inst✝ : AddCommMonoid β
f : ι →₀ α
i : ι
a : α
g : ι → α → β
hg : ∀ (i : ι), g i 0 = 0
hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂
⊢ ((sum (erase i f) fun a => g a) + sum (single i a) fun a => g a) + g i (↑f i) = sum (update f i (↑f i)) g + g i a

tactic: congr 1
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285219
ι : Type u_3
M : Type ?u.285225
M' : Type ?u.285228
N : Type ?u.285231
P : Type ?u.285234
G : Type ?u.285237
H : Type ?u.285240
R : Type ?u.285243
S : Type ?u.285246
inst✝² : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝¹ : AddCommMonoid α
inst✝ : AddCommMonoid β
f : ι →₀ α
i : ι
a : α
g : ι → α → β
hg : ∀ (i : ι), g i 0 = 0
hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂
⊢ (sum (erase i f) fun a => g a) + ((sum (single i a) fun a => g a) + g i (↑f i)) =
    (sum (erase i f) fun a => g a) + ((sum (single i (↑f i)) fun a => g a) + g i a)

tactic: rw [add_comm, sum_single_index (hg _), sum_single_index (hg _)]
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type ?u.285219
ι : Type u_3
M : Type ?u.285225
M' : Type ?u.285228
N : Type ?u.285231
P : Type ?u.285234
G : Type ?u.285237
H : Type ?u.285240
R : Type ?u.285243
S : Type ?u.285246
inst✝² : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝¹ : AddCommMonoid α
inst✝ : AddCommMonoid β
f : ι →₀ α
i : ι
a : α
g : ι → α → β
hg : ∀ (i : ι), g i 0 = 0
hgg : ∀ (j : ι) (a₁ a₂ : α), g j (a₁ + a₂) = g j a₁ + g j a₂
⊢ (sum (single i a) fun a => g a) + g i (↑f i) = (sum (single i (↑f i)) fun a => g a) + g i a
Theorem: List.find?_cons_of_pos
File: Std/Data/List/Lemmas.lean

tactic: simp [find?, h]
state_before: α✝ : Type u_1
p : α✝ → Bool
a : α✝
l : List α✝
h : p a = true
⊢ find? p (a :: l) = some a
Theorem: Matrix.mulVec_vecMul
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [← mulVec_mulVec, mulVec_transpose]
state_before: l : Type ?u.917788
m : Type u_3
n : Type u_1
o : Type u_2
m' : o → Type ?u.917802
n' : o → Type ?u.917807
R : Type ?u.917810
S : Type ?u.917813
α : Type v
β : Type w
γ : Type ?u.917820
inst✝² : NonUnitalCommSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype o
A : Matrix m n α
B : Matrix o n α
x : o → α
⊢ mulVec A (vecMul x B) = mulVec (A ⬝ Bᵀ) x
Theorem: UV.compression_self
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: unfold compression
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a b u : α
s : Finset α
⊢ 𝓒 u u s = s

tactic: convert union_empty s
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a b u : α
s : Finset α
⊢ filter (fun a => compress u u a ∈ s) s ∪ filter (fun a => ¬a ∈ s) (image (compress u u) s) = s

tactic: ext a
state_before: case h.e'_2.h.e'_3
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a b u : α
s : Finset α
⊢ filter (fun a => compress u u a ∈ s) s = s

tactic: simp [mem_filter, compress_self, and_self_iff]
state_before: case h.e'_2.h.e'_3.a
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a✝ b u : α
s : Finset α
a : α
⊢ a ∈ filter (fun a => compress u u a ∈ s) s ↔ a ∈ s

tactic: refine' eq_empty_of_forall_not_mem fun a ha => _
state_before: case h.e'_2.h.e'_4
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a b u : α
s : Finset α
⊢ filter (fun a => ¬a ∈ s) (image (compress u u) s) = ∅

tactic: simp_rw [mem_filter, mem_image, compress_self] at ha
state_before: case h.e'_2.h.e'_4
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a✝ b u : α
s : Finset α
a : α
ha : a ∈ filter (fun a => ¬a ∈ s) (image (compress u u) s)
⊢ False

tactic: obtain ⟨⟨b, hb, rfl⟩, hb'⟩ := ha
state_before: case h.e'_2.h.e'_4
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a✝ b u : α
s : Finset α
a : α
ha : (∃ a_1, a_1 ∈ s ∧ a_1 = a) ∧ ¬a ∈ s
⊢ False

tactic: exact hb' hb
state_before: case h.e'_2.h.e'_4.intro.intro.intro
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v a b✝ u : α
s : Finset α
b : α
hb : b ∈ s
hb' : ¬b ∈ s
⊢ False
Theorem: Fin.prod_univ_succAbove
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [univ_succAbove, prod_cons, Finset.prod_map _ x.succAbove.toEmbedding,
  RelEmbedding.coe_toEmbedding]
state_before: α : Type ?u.4109
β : Type u_1
inst✝ : CommMonoid β
n : ℕ
f : Fin (n + 1) → β
x : Fin (n + 1)
⊢ ∏ i : Fin (n + 1), f i = f x * ∏ i : Fin n, f (↑(succAbove x) i)
Theorem: MeasureTheory.Integrable.smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at h ⊢
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.846855
δ : Type ?u.846858
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ Integrable f

tactic: exact h.smul_measure hc
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.846855
δ : Type ?u.846858
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Memℒp f 1
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ Memℒp f 1
Theorem: Set.insert_diff_self_of_not_mem
File: Mathlib/Data/Set/Basic.lean

tactic: ext x
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : ¬a ∈ s
⊢ insert a s \ {a} = s

tactic: simp [and_iff_left_of_imp fun hx : x ∈ s => show x ≠ a from fun hxa => h <| hxa ▸ hx]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : ¬a ∈ s
x : α
⊢ x ∈ insert a s \ {a} ↔ x ∈ s
Theorem: Substring.ValidFor.toString
File: Std/Data/String/Lemmas.lean

tactic: simpa [Substring.toString] using extract_of_valid l m r
state_before: l m r : List Char
⊢ Substring.toString
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
        stopPos := { byteIdx := utf8Len l + utf8Len m } } =
    { data := m }
Theorem: List.rdropWhile_eq_self_iff
File: Mathlib/Data/List/Rdrop.lean

tactic: simp only [rdropWhile, reverse_eq_iff, dropWhile_eq_self_iff, getLast_eq_get]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rdropWhile p l = l ↔ ∀ (hl : l ≠ []), ¬p (getLast l hl) = true

tactic: refine' ⟨fun h hl => _, fun h hl => _⟩
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ (∀ (hl : 0 < length (reverse l)), ¬p (nthLe (reverse l) 0 hl) = true) ↔
    ∀ (hl : l ≠ []), ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true

tactic: rw [← length_pos, ← length_reverse] at hl
state_before: case refine'_1
α : Type u_1
p : α → Bool
l : List α
n : ℕ
h : ∀ (hl : 0 < length (reverse l)), ¬p (nthLe (reverse l) 0 hl) = true
hl : l ≠ []
⊢ ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true

tactic: have := h hl
state_before: case refine'_1
α : Type u_1
p : α → Bool
l : List α
n : ℕ
h : ∀ (hl : 0 < length (reverse l)), ¬p (nthLe (reverse l) 0 hl) = true
hl✝ : l ≠ []
hl : 0 < length (reverse l)
⊢ ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true

tactic: rwa [nthLe, get_reverse'] at this
state_before: case refine'_1
α : Type u_1
p : α → Bool
l : List α
n : ℕ
h : ∀ (hl : 0 < length (reverse l)), ¬p (nthLe (reverse l) 0 hl) = true
hl✝ : l ≠ []
hl : 0 < length (reverse l)
this : ¬p (nthLe (reverse l) 0 hl) = true
⊢ ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true

tactic: rw [length_reverse, length_pos] at hl
state_before: case refine'_2
α : Type u_1
p : α → Bool
l : List α
n : ℕ
h : ∀ (hl : l ≠ []), ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true
hl : 0 < length (reverse l)
⊢ ¬p (nthLe (reverse l) 0 hl) = true

tactic: have := h hl
state_before: case refine'_2
α : Type u_1
p : α → Bool
l : List α
n : ℕ
h : ∀ (hl : l ≠ []), ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true
hl✝ : 0 < length (reverse l)
hl : l ≠ []
⊢ ¬p (nthLe (reverse l) 0 hl✝) = true

tactic: rwa [nthLe, get_reverse']
state_before: case refine'_2
α : Type u_1
p : α → Bool
l : List α
n : ℕ
h : ∀ (hl : l ≠ []), ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true
hl✝ : 0 < length (reverse l)
hl : l ≠ []
this : ¬p (get l { val := length l - 1, isLt := (_ : length l - 1 < length l) }) = true
⊢ ¬p (nthLe (reverse l) 0 hl✝) = true
Theorem: MeasureTheory.JordanDecomposition.toSignedMeasure_zero
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: ext1 i hi
state_before: α : Type u_1
β : Type ?u.16597
inst✝ : MeasurableSpace α
j : JordanDecomposition α
⊢ toSignedMeasure 0 = 0

tactic: rw [toSignedMeasure, toSignedMeasure_sub_apply hi, zero_posPart, zero_negPart, sub_self,
  VectorMeasure.coe_zero, Pi.zero_apply]
state_before: case h
α : Type u_1
β : Type ?u.16597
inst✝ : MeasurableSpace α
j : JordanDecomposition α
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i
Theorem: CategoryTheory.Limits.Multifork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← app_right_eq_ι_comp_fst, ← app_right_eq_ι_comp_snd]
state_before: C : Type u
inst✝ : Category C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ ι K (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
    ι K (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
Theorem: eq_of_nndist_eq_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [← NNReal.eq_iff, ← dist_nndist, imp_self, NNReal.coe_zero, dist_eq_zero]
state_before: α : Type u
β : Type v
X : Type ?u.551568
ι : Type ?u.551571
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ nndist x y = 0 → x = y
Theorem: Int.eq_one_of_mul_eq_self_right
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.mul_one, H]
state_before: a b : Int
Hpos : b ≠ 0
H : b * a = b
⊢ b * a = b * 1
Theorem: Equiv.Perm.ModSumCongr.swap_smul_involutive
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: refine Quotient.inductionOn' σ fun σ => ?_
state_before: R : Type ?u.810983
inst✝²⁰ : Semiring R
M : Type ?u.810989
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : Module R M
N : Type ?u.811021
inst✝¹⁷ : AddCommMonoid N
inst✝¹⁶ : Module R N
P : Type ?u.811051
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : Module R P
M' : Type ?u.811081
inst✝¹³ : AddCommGroup M'
inst✝¹² : Module R M'
N' : Type ?u.811469
inst✝¹¹ : AddCommGroup N'
inst✝¹⁰ : Module R N'
ι : Type ?u.811857
ι' : Type ?u.811860
ι'' : Type ?u.811863
ιa : Type ?u.811866
ιb : Type ?u.811869
inst✝⁹ : Fintype ιa
inst✝⁸ : Fintype ιb
R' : Type ?u.811878
Mᵢ : Type ?u.811881
N₁ : Type ?u.811884
N₂ : Type ?u.811887
inst✝⁷ : CommSemiring R'
inst✝⁶ : AddCommGroup N₁
inst✝⁵ : Module R' N₁
inst✝⁴ : AddCommGroup N₂
inst✝³ : Module R' N₂
inst✝² : AddCommMonoid Mᵢ
inst✝¹ : Module R' Mᵢ
α : Type u_1
β : Type u_2
inst✝ : DecidableEq (α ⊕ β)
i j : α ⊕ β
σ : ModSumCongr α β
⊢ SMul.smul (swap i j) (SMul.smul (swap i j) σ) = σ

tactic: exact _root_.congr_arg Quotient.mk'' (Equiv.swap_mul_involutive i j σ)
state_before: R : Type ?u.810983
inst✝²⁰ : Semiring R
M : Type ?u.810989
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : Module R M
N : Type ?u.811021
inst✝¹⁷ : AddCommMonoid N
inst✝¹⁶ : Module R N
P : Type ?u.811051
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : Module R P
M' : Type ?u.811081
inst✝¹³ : AddCommGroup M'
inst✝¹² : Module R M'
N' : Type ?u.811469
inst✝¹¹ : AddCommGroup N'
inst✝¹⁰ : Module R N'
ι : Type ?u.811857
ι' : Type ?u.811860
ι'' : Type ?u.811863
ιa : Type ?u.811866
ιb : Type ?u.811869
inst✝⁹ : Fintype ιa
inst✝⁸ : Fintype ιb
R' : Type ?u.811878
Mᵢ : Type ?u.811881
N₁ : Type ?u.811884
N₂ : Type ?u.811887
inst✝⁷ : CommSemiring R'
inst✝⁶ : AddCommGroup N₁
inst✝⁵ : Module R' N₁
inst✝⁴ : AddCommGroup N₂
inst✝³ : Module R' N₂
inst✝² : AddCommMonoid Mᵢ
inst✝¹ : Module R' Mᵢ
α : Type u_1
β : Type u_2
inst✝ : DecidableEq (α ⊕ β)
i j : α ⊕ β
σ✝ : ModSumCongr α β
σ : Perm (α ⊕ β)
⊢ SMul.smul (swap i j) (SMul.smul (swap i j) (Quotient.mk'' σ)) = Quotient.mk'' σ
Theorem: AffineSubspace.sOppSide_pointReflection
File: Mathlib/Analysis/Convex/Side.lean

tactic: refine' (sbtw_pointReflection_of_ne R fun h => hy _).sOppSide_of_not_mem_of_mem hy hx
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.453341
P : Type u_3
P' : Type ?u.453347
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
hy : ¬y ∈ s
⊢ SOppSide s y (↑(pointReflection R x) y)

tactic: rwa [← h]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.453341
P : Type u_3
P' : Type ?u.453347
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
hy : ¬y ∈ s
h : x = y
⊢ y ∈ s