1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.destutter'_is_chain
File: Mathlib/Data/List/Destutter.lean

tactic: rw [destutter']
state_before: α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
⊢ Chain R a (destutter' R b (c :: l))
state_after: α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
⊢ Chain R a (if R b c then b :: destutter' R c l else destutter' R b l)

tactic: split_ifs with hbc
state_before: α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
⊢ Chain R a (if R b c then b :: destutter' R c l else destutter' R b l)
state_after: case pos
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
hbc : R b c
⊢ Chain R a (b :: destutter' R c l)

case neg
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
hbc : ¬R b c
⊢ Chain R a (destutter' R b l)

tactic: rw [chain_cons]
state_before: case pos
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
hbc : R b c
⊢ Chain R a (b :: destutter' R c l)
state_after: case pos
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
hbc : R b c
⊢ R a b ∧ Chain R b (destutter' R c l)

tactic: exact ⟨h, destutter'_is_chain l hbc⟩
state_before: case pos
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
hbc : R b c
⊢ R a b ∧ Chain R b (destutter' R c l)
state_after: no goals

tactic: exact destutter'_is_chain l h
state_before: case neg
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ c : α
l : List α
a b : α
h : R a b
hbc : ¬R b c
⊢ Chain R a (destutter' R b l)
state_after: no goals
Theorem: Cubic.b_eq_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: injection eq_sum_three_roots ha h3
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ φ P.b = φ P.a * -(x + y + z)
state_after: no goals
Theorem: Associated.symm
File: Mathlib/Algebra/Associated.lean

tactic: rw [mul_assoc, Units.mul_inv, mul_one]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
x : α
u : αˣ
⊢ x * ↑u * ↑u⁻¹ = x
state_after: no goals
Theorem: le_padicValNat_iff_replicate_subperm_factors
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [← le_multiplicity_iff_replicate_subperm_factors ha hb,
  ← padicValNat_def' ha.ne_one (Nat.pos_of_ne_zero hb), Nat.cast_le]
state_before: p a b n : ℕ
ha : Nat.Prime a
hb : b ≠ 0
⊢ n ≤ padicValNat a b ↔ replicate n a <+~ b.factors
state_after: no goals
Theorem: FinVec.forall_iff
File: Mathlib/Data/Fin/Tuple/Reflection.lean

tactic: simp only [Forall, Fin.forall_fin_zero_pi]
state_before: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ Forall P ↔ ∀ (x : Fin 0 → α), P x
state_after: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ P ![] ↔ P finZeroElim

tactic: rfl
state_before: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ P ![] ↔ P finZeroElim
state_after: no goals

tactic: simp only [Forall, forall_iff, Fin.forall_fin_succ_pi, Matrix.vecCons]
state_before: m n✝ : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
P : (Fin n.succ → α) → Prop
⊢ Forall P ↔ ∀ (x : Fin n.succ → α), P x
state_after: no goals
Theorem: Finmap.lookup_union_left_of_not_in
File: Mathlib/Data/Finmap.lean

tactic: by_cases h' : a ∈ s₁
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁
state_after: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
h' : a ∈ s₁
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁

case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
h' : a ∉ s₁
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁

tactic: rw [lookup_union_left h']
state_before: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
h' : a ∈ s₁
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁
state_after: no goals

tactic: rw [lookup_union_right h', lookup_eq_none.mpr h, lookup_eq_none.mpr h']
state_before: case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s₁ s₂ : Finmap β
h : a ∉ s₂
h' : a ∉ s₁
⊢ lookup a (s₁ ∪ s₂) = lookup a s₁
state_after: no goals
Theorem: Set.Ioc_inter_Ioi
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← Ioi_inter_Iic, inter_assoc, inter_comm, inter_assoc, Ioi_inter_Ioi, inter_comm,
  Ioi_inter_Iic, sup_comm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∩ Ioi c = Ioc (a ⊔ c) b
state_after: no goals
Theorem: Real.sin_sub_sin
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sin_sub_sin]
state_before: x y : ℝ
⊢ ↑(sin x - sin y) = ↑(2 * sin ((x - y) / 2) * cos ((x + y) / 2))
state_after: no goals
Theorem: GradedMonoid.list_prod_map_eq_dProd
File: Mathlib/Algebra/GradedMonoid.lean

tactic: rw [GradedMonoid.mk_list_dProd, GradedMonoid.mk]
state_before: ι : Type u_1
α : Type u_2
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
l : List α
f : α → GradedMonoid A
⊢ (List.map f l).prod = mk (l.dProdIndex fun i => (f i).fst) (l.dProd (fun i => (f i).fst) fun i => (f i).snd)
state_after: ι : Type u_1
α : Type u_2
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
l : List α
f : α → GradedMonoid A
⊢ (List.map f l).prod = (List.map (fun a => ⟨(f a).fst, (f a).snd⟩) l).prod

tactic: simp_rw [Sigma.eta]
state_before: ι : Type u_1
α : Type u_2
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
l : List α
f : α → GradedMonoid A
⊢ (List.map f l).prod = (List.map (fun a => ⟨(f a).fst, (f a).snd⟩) l).prod
state_after: no goals
Theorem: MeasureTheory.Integrable.measure_ge_lt_top
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: refine lt_of_le_of_lt (measure_mono ?_) (hf.measure_norm_ge_lt_top ε_pos)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
⊢ μ {a | ε ≤ f a} < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
⊢ {a | ε ≤ f a} ⊆ {x | ε ≤ ‖f x‖}

tactic: intro x hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
⊢ {a | ε ≤ f a} ⊆ {x | ε ≤ ‖f x‖}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : x ∈ {a | ε ≤ f a}
⊢ x ∈ {x | ε ≤ ‖f x‖}

tactic: simp only [Real.norm_eq_abs, Set.mem_setOf_eq] at hx ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : x ∈ {a | ε ≤ f a}
⊢ x ∈ {x | ε ≤ ‖f x‖}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : ε ≤ f x
⊢ ε ≤ |f x|

tactic: exact hx.trans (le_abs_self _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
ε : ℝ
ε_pos : 0 < ε
x : α
hx : ε ≤ f x
⊢ ε ≤ |f x|
state_after: no goals
Theorem: Complex.dist_eq_re_im
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [sq, sq]
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
⊢ dist z w = √((z.re - w.re) ^ 2 + (z.im - w.im) ^ 2)
state_after: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
⊢ dist z w = √((z.re - w.re) * (z.re - w.re) + (z.im - w.im) * (z.im - w.im))

tactic: rfl
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
⊢ dist z w = √((z.re - w.re) * (z.re - w.re) + (z.im - w.im) * (z.im - w.im))
state_after: no goals
Theorem: Metric.preimage_mul_right_ball
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b / a) r
state_after: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b * a⁻¹) r

tactic: exact preimage_smul_ball (MulOpposite.op a) b r
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b * a⁻¹) r
state_after: no goals
Theorem: Polynomial.degree_pow_le_of_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: induction b with
| zero => simp [degree_one_le]
| succ n hn =>
    rw [Nat.cast_succ, add_mul, one_mul, pow_succ]
    exact degree_mul_le_of_le hn hp
state_before: R : Type u
S : Type v
a✝ b✝ c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : WithBot ℕ
b : ℕ
hp : p.degree ≤ a
⊢ (p ^ b).degree ≤ ↑b * a
state_after: no goals

tactic: simp [degree_one_le]
state_before: case zero
R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : WithBot ℕ
hp : p.degree ≤ a
⊢ (p ^ 0).degree ≤ ↑0 * a
state_after: no goals

tactic: rw [Nat.cast_succ, add_mul, one_mul, pow_succ]
state_before: case succ
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : WithBot ℕ
hp : p.degree ≤ a
n : ℕ
hn : (p ^ n).degree ≤ ↑n * a
⊢ (p ^ (n + 1)).degree ≤ ↑(n + 1) * a
state_after: case succ
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : WithBot ℕ
hp : p.degree ≤ a
n : ℕ
hn : (p ^ n).degree ≤ ↑n * a
⊢ (p ^ n * p).degree ≤ ↑n * a + a

tactic: exact degree_mul_le_of_le hn hp
state_before: case succ
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : WithBot ℕ
hp : p.degree ≤ a
n : ℕ
hn : (p ^ n).degree ≤ ↑n * a
⊢ (p ^ n * p).degree ≤ ↑n * a + a
state_after: no goals
Theorem: seq_map_assoc
File: Mathlib/Control/Basic.lean

tactic: simp only [← pure_seq]
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
x : F (α → β)
f : γ → α
y : F γ
⊢ (Seq.seq x fun x => f <$> y) = Seq.seq ((fun x => x ∘ f) <$> x) fun x => y
state_after: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
x : F (α → β)
f : γ → α
y : F γ
⊢ (Seq.seq x fun x => Seq.seq (pure f) fun x => y) = Seq.seq (Seq.seq (pure fun x => x ∘ f) fun x_1 => x) fun x => y

tactic: simp only [seq_assoc, Function.comp, seq_pure, ← comp_map]
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
x : F (α → β)
f : γ → α
y : F γ
⊢ (Seq.seq x fun x => Seq.seq (pure f) fun x => y) = Seq.seq (Seq.seq (pure fun x => x ∘ f) fun x_1 => x) fun x => y
state_after: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
x : F (α → β)
f : γ → α
y : F γ
⊢ (Seq.seq ((fun x x_1 => x (f x_1)) <$> x) fun x => y) =
    Seq.seq (Seq.seq (pure fun x x_1 => x (f x_1)) fun x_1 => x) fun x => y

tactic: simp [pure_seq]
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
x : F (α → β)
f : γ → α
y : F γ
⊢ (Seq.seq ((fun x x_1 => x (f x_1)) <$> x) fun x => y) =
    Seq.seq (Seq.seq (pure fun x x_1 => x (f x_1)) fun x_1 => x) fun x => y
state_after: no goals
Theorem: mem_nhdsSet_iff_exists
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [← subset_interior_iff_mem_nhdsSet, subset_interior_iff]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ s ∈ 𝓝ˢ t ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s
state_after: no goals
Theorem: abs_dist_sub_le_dist_mul_mul
File: Mathlib/Analysis/Normed/Group/Uniform.lean

tactic: simpa only [dist_mul_left, dist_mul_right, dist_comm b₂] using
  abs_dist_sub_le (a₁ * a₂) (b₁ * b₂) (b₁ * a₂)
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁✝ a₂✝ b b₁✝ b₂✝ : E
r r₁ r₂ : ℝ
a₁ a₂ b₁ b₂ : E
⊢ |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂)
state_after: no goals
Theorem: PNat.le_sub_one_of_lt
File: Mathlib/Data/PNat/Basic.lean

tactic: rw [← coe_le_coe, sub_coe]
state_before: a b : ℕ+
hab : a < b
⊢ a ≤ b - 1
state_after: a b : ℕ+
hab : a < b
⊢ ↑a ≤ if 1 < b then ↑b - ↑1 else 1

tactic: split_ifs with h
state_before: a b : ℕ+
hab : a < b
⊢ ↑a ≤ if 1 < b then ↑b - ↑1 else 1
state_after: case pos
a b : ℕ+
hab : a < b
h : 1 < b
⊢ ↑a ≤ ↑b - ↑1

case neg
a b : ℕ+
hab : a < b
h : ¬1 < b
⊢ ↑a ≤ 1

tactic: exact Nat.le_pred_of_lt hab
state_before: case pos
a b : ℕ+
hab : a < b
h : 1 < b
⊢ ↑a ≤ ↑b - ↑1
state_after: no goals

tactic: exact hab.le.trans (le_of_not_lt h)
state_before: case neg
a b : ℕ+
hab : a < b
h : ¬1 < b
⊢ ↑a ≤ 1
state_after: no goals
Theorem: MeasureTheory.absolutelyContinuous_map_mul_right
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: refine AbsolutelyContinuous.mk fun s hs => ?_
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun x => x * g) μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ (map (fun x => x * g) μ) s = 0 → μ s = 0

tactic: rw [map_apply (measurable_mul_const g) hs, measure_mul_right_null]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ (map (fun x => x * g) μ) s = 0 → μ s = 0
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ μ s = 0 → μ s = 0

tactic: exact id
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
s : Set G
hs : MeasurableSet s
⊢ μ s = 0 → μ s = 0
state_after: no goals
Theorem: OreLocalization.smul_cancel'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_smul_char (r₁ * s) r₂ t s r₁ 1 (by simp)]
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r₁ : R
r₂ : X
s t : ↥S
⊢ (r₁ * ↑s /ₒ t) • (r₂ /ₒ s) = r₁ • r₂ /ₒ t
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r₁ : R
r₂ : X
s t : ↥S
⊢ ↑1 * (r₁ * ↑s) = r₁ * ↑s
state_after: no goals
Theorem: ContinuousMultilinearMap.uncurry0_norm
File: Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean

tactic: simp
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
⊢ ‖f.uncurry0‖ = ‖f‖
state_after: no goals
Theorem: ContinuousLinearMap.norm_precompR_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean

tactic: rw [one_mul]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁹ : SeminormedAddCommGroup E
inst✝¹⁸ : SeminormedAddCommGroup Eₗ
inst✝¹⁷ : SeminormedAddCommGroup F
inst✝¹⁶ : SeminormedAddCommGroup Fₗ
inst✝¹⁵ : SeminormedAddCommGroup G
inst✝¹⁴ : SeminormedAddCommGroup Gₗ
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : NontriviallyNormedField 𝕜₃
inst✝¹⁰ : NormedSpace 𝕜 E
inst✝⁹ : NormedSpace 𝕜 Eₗ
inst✝⁸ : NormedSpace 𝕜₂ F
inst✝⁷ : NormedSpace 𝕜 Fₗ
inst✝⁶ : NormedSpace 𝕜₃ G
inst✝⁵ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : FunLike 𝓕 E F
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ 1 * ‖L‖ = ‖L‖
state_after: no goals
Theorem: PrimeMultiset.prod_dvd_iff
File: Mathlib/Data/PNat/Factors.lean

tactic: let h := @PNat.factorMultiset_le_iff' u.prod v
state_before: u v : PrimeMultiset
⊢ u.prod ∣ v.prod ↔ u ≤ v
state_after: u v : PrimeMultiset
h : u.prod.factorMultiset ≤ v ↔ u.prod ∣ v.prod := PNat.factorMultiset_le_iff'
⊢ u.prod ∣ v.prod ↔ u ≤ v

tactic: rw [u.factorMultiset_prod] at h
state_before: u v : PrimeMultiset
h : u.prod.factorMultiset ≤ v ↔ u.prod ∣ v.prod := PNat.factorMultiset_le_iff'
⊢ u.prod ∣ v.prod ↔ u ≤ v
state_after: u v : PrimeMultiset
h : u ≤ v ↔ u.prod ∣ v.prod
⊢ u.prod ∣ v.prod ↔ u ≤ v

tactic: exact h.symm
state_before: u v : PrimeMultiset
h : u ≤ v ↔ u.prod ∣ v.prod
⊢ u.prod ∣ v.prod ↔ u ≤ v
state_after: no goals
Theorem: HasDerivAt.lhopital_zero_nhds'
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: simp only [← Iio_union_Ioi, nhdsWithin_union, tendsto_sup, eventually_sup] at *
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝[≠] a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝[≠] a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝[≠] a, g' x ≠ 0
hfa : Tendsto f (𝓝[≠] a) (𝓝 0)
hga : Tendsto g (𝓝[≠] a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[≠] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[≠] a) l
state_after: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : (∀ᶠ (x : ℝ) in 𝓝[<] a, HasDerivAt f (f' x) x) ∧ ∀ᶠ (x : ℝ) in 𝓝[>] a, HasDerivAt f (f' x) x
hgg' : (∀ᶠ (x : ℝ) in 𝓝[<] a, HasDerivAt g (g' x) x) ∧ ∀ᶠ (x : ℝ) in 𝓝[>] a, HasDerivAt g (g' x) x
hg' : (∀ᶠ (x : ℝ) in 𝓝[<] a, g' x ≠ 0) ∧ ∀ᶠ (x : ℝ) in 𝓝[>] a, g' x ≠ 0
hfa : Tendsto f (𝓝[<] a) (𝓝 0) ∧ Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[<] a) (𝓝 0) ∧ Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[<] a) l ∧ Tendsto (fun x => f' x / g' x) (𝓝[>] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[<] a) l ∧ Tendsto (fun x => f x / g x) (𝓝[>] a) l

tactic: exact ⟨lhopital_zero_nhds_left hff'.1 hgg'.1 hg'.1 hfa.1 hga.1 hdiv.1,
  lhopital_zero_nhds_right hff'.2 hgg'.2 hg'.2 hfa.2 hga.2 hdiv.2⟩
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : (∀ᶠ (x : ℝ) in 𝓝[<] a, HasDerivAt f (f' x) x) ∧ ∀ᶠ (x : ℝ) in 𝓝[>] a, HasDerivAt f (f' x) x
hgg' : (∀ᶠ (x : ℝ) in 𝓝[<] a, HasDerivAt g (g' x) x) ∧ ∀ᶠ (x : ℝ) in 𝓝[>] a, HasDerivAt g (g' x) x
hg' : (∀ᶠ (x : ℝ) in 𝓝[<] a, g' x ≠ 0) ∧ ∀ᶠ (x : ℝ) in 𝓝[>] a, g' x ≠ 0
hfa : Tendsto f (𝓝[<] a) (𝓝 0) ∧ Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[<] a) (𝓝 0) ∧ Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[<] a) l ∧ Tendsto (fun x => f' x / g' x) (𝓝[>] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[<] a) l ∧ Tendsto (fun x => f x / g x) (𝓝[>] a) l
state_after: no goals
Theorem: LipschitzWith.of_le_add_mul
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [Real.toNNReal_coe] using LipschitzWith.of_le_add_mul' K h
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ
f : α → ℝ
K : ℝ≥0
h : ∀ (x y : α), f x ≤ f y + ↑K * dist x y
⊢ LipschitzWith K f
state_after: no goals
Theorem: LipschitzWith.norm_compLp_le
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simpa using hg.norm_compLp_sub_le g0 f 0
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
f : ↥(Lp E p μ)
⊢ ‖hg.compLp g0 f‖ ≤ ↑c * ‖f‖
state_after: no goals
Theorem: List.toFinset_append
File: Mathlib/Data/Finset/Basic.lean

tactic: induction' l with hd tl hl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ (l ++ l').toFinset = l.toFinset ∪ l'.toFinset
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ ([] ++ l').toFinset = [].toFinset ∪ l'.toFinset

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a hd : α
tl : List α
hl : (tl ++ l').toFinset = tl.toFinset ∪ l'.toFinset
⊢ (hd :: tl ++ l').toFinset = (hd :: tl).toFinset ∪ l'.toFinset

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ ([] ++ l').toFinset = [].toFinset ∪ l'.toFinset
state_after: no goals

tactic: simp [hl]
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a hd : α
tl : List α
hl : (tl ++ l').toFinset = tl.toFinset ∪ l'.toFinset
⊢ (hd :: tl ++ l').toFinset = (hd :: tl).toFinset ∪ l'.toFinset
state_after: no goals
Theorem: zsmul_eq_mul
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: rw [natCast_zsmul, nsmul_eq_mul, Int.cast_natCast]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : NonAssocRing α
a✝ b : α
n✝ : ℤ
a : α
n : ℕ
⊢ ↑n • a = ↑↑n * a
state_after: no goals

tactic: simp [Nat.cast_succ, neg_add_rev, Int.cast_negSucc, add_mul]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : NonAssocRing α
a✝ b : α
n✝ : ℤ
a : α
n : ℕ
⊢ -[n+1] • a = ↑-[n+1] * a
state_after: no goals
Theorem: Polynomial.reflect_C
File: Mathlib/Algebra/Polynomial/Reverse.lean

tactic: conv_lhs => rw [← mul_one (C r), ← pow_zero X, reflect_C_mul_X_pow, revAt_zero]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
r : R
N : ℕ
⊢ reflect N (C r) = C r * X ^ N
state_after: no goals