tasksource/leandojo huggingface dataset:
Theorem: Real.mul_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: iterate 2 rw [Real.rpow_def_of_nonneg]; split_ifs with h_ifs <;> simp_all
state_before: x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
⊢ (x * y) ^ z = x ^ z * y ^ z

tactic: rw [Real.rpow_def_of_nonneg]
state_before: case inl.inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : x = 0 ∨ y = 0
h✝ : ¬z = 0
⊢ x ^ z = 0 ∨ y ^ z = 0

case inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬(x = 0 ∨ y = 0)
⊢ exp (log (x * y) * z) = x ^ z * y ^ z

case hx
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
⊢ 0 ≤ x * y

tactic: split_ifs with h_ifs <;> simp_all
state_before: case inl.inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : x = 0 ∨ y = 0
h✝ : ¬z = 0
⊢ (if x = 0 then if z = 0 then 1 else 0 else exp (log x * z)) = 0 ∨ y ^ z = 0

case inl.inr.hx
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : x = 0 ∨ y = 0
h✝ : ¬z = 0
⊢ 0 ≤ x

case inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬(x = 0 ∨ y = 0)
⊢ exp (log (x * y) * z) = x ^ z * y ^ z

case hx
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
⊢ 0 ≤ x * y

tactic: exact h
state_before: case inl.inr.hx
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : x = 0 ∨ y = 0
h✝ : ¬z = 0
⊢ 0 ≤ x

tactic: rw [not_or] at h_ifs
state_before: case inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬(x = 0 ∨ y = 0)
⊢ exp (log (x * y) * z) = x ^ z * y ^ z

tactic: rw [log_mul (ne_of_gt hx) (ne_of_gt hy), add_mul, exp_add, rpow_def_of_pos hx,
  rpow_def_of_pos hy]
state_before: case inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
hx : 0 < x
hy : 0 < y
⊢ exp (log (x * y) * z) = x ^ z * y ^ z

tactic: cases' lt_or_eq_of_le h with h₂ h₂
state_before: x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ 0 < x

tactic: exfalso
state_before: case inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
h₂ : 0 = x
⊢ 0 < x

tactic: apply h_ifs.1
state_before: case inr.h
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
h₂ : 0 = x
⊢ False

tactic: exact Eq.symm h₂
state_before: case inr.h
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
h₂ : 0 = x
⊢ x = 0

tactic: exact h₂
state_before: case inl
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
h₂ : 0 < x
⊢ 0 < x

tactic: cases' lt_or_eq_of_le h₁ with h₂ h₂
state_before: x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
hx : 0 < x
⊢ 0 < y

tactic: exfalso
state_before: case inr
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
hx : 0 < x
h₂ : 0 = y
⊢ 0 < y

tactic: apply h_ifs.2
state_before: case inr.h
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
hx : 0 < x
h₂ : 0 = y
⊢ False

tactic: exact Eq.symm h₂
state_before: case inr.h
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
hx : 0 < x
h₂ : 0 = y
⊢ y = 0

tactic: exact h₂
state_before: case inl
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
hx : 0 < x
h₂ : 0 < y
⊢ 0 < y

tactic: exact mul_nonneg h h₁
state_before: case hx
x✝ y✝ z✝ x y z : ℝ
h : 0 ≤ x
h₁ : 0 ≤ y
⊢ 0 ≤ x * y
Theorem: MvPolynomial.totalDegree_neg
File: Mathlib/Data/MvPolynomial/CommRing.lean

tactic: simp only [totalDegree, support_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p q a : MvPolynomial σ R
⊢ totalDegree (-a) = totalDegree a
Theorem: List.splitOnP_first
File: Mathlib/Data/List/Basic.lean

tactic: induction xs with
| nil => simp [hsep]
| cons hd tl ih => simp [h hd _, ih <| forall_mem_of_forall_mem_cons h]
state_before: ι : Type ?u.302857
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
h : ∀ (x : α), x ∈ xs → ¬p x = true
sep : α
hsep : p sep = true
as : List α
⊢ splitOnP p (xs ++ sep :: as) = xs :: splitOnP p as

tactic: simp [hsep]
state_before: case nil
ι : Type ?u.302857
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
sep : α
hsep : p sep = true
as : List α
h : ∀ (x : α), x ∈ [] → ¬p x = true
⊢ splitOnP p ([] ++ sep :: as) = [] :: splitOnP p as

tactic: simp [h hd _, ih <| forall_mem_of_forall_mem_cons h]
state_before: case cons
ι : Type ?u.302857
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
sep : α
hsep : p sep = true
as : List α
hd : α
tl : List α
ih : (∀ (x : α), x ∈ tl → ¬p x = true) → splitOnP p (tl ++ sep :: as) = tl :: splitOnP p as
h : ∀ (x : α), x ∈ hd :: tl → ¬p x = true
⊢ splitOnP p (hd :: tl ++ sep :: as) = (hd :: tl) :: splitOnP p as
Theorem: Polynomial.coeff_C_ne_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [coeff_C, if_neg h]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
h : n ≠ 0
⊢ coeff (↑C a) n = 0
Theorem: Finset.prod_apply_dite
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.387864
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter p s }
⊢ p ↑x

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.387864
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter (fun x => ¬p x) s }
⊢ ¬p ↑x

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.387864
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter p s }
⊢ p ↑x

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.387864
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter (fun x => ¬p x) s }
⊢ ¬p ↑x

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.387864
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter p s }
_hx : x ∈ attach (filter p s)
⊢ p ↑x

tactic: simpa using (mem_filter.mp x.2).2
state_before: ι : Type ?u.387864
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter (fun x => ¬p x) s }
_hx : x ∈ attach (filter (fun x => ¬p x) s)
⊢ ¬p ↑x
Theorem: MeasureTheory.Measure.measure_le_sInf
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [sInf_apply hs]
state_before: α : Type u_1
β : Type ?u.152195
γ : Type ?u.152198
δ : Type ?u.152201
ι : Type ?u.152204
R : Type ?u.152207
R' : Type ?u.152210
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
m : Set (Measure α)
h : ∀ (μ' : Measure α), μ' ∈ m → μ ≤ μ'
this : ↑μ ≤ sInf (toOuterMeasure '' m)
s : Set α
hs : MeasurableSet s
⊢ ↑↑μ s ≤ ↑↑(sInf m) s

tactic: exact this s
state_before: α : Type u_1
β : Type ?u.152195
γ : Type ?u.152198
δ : Type ?u.152201
ι : Type ?u.152204
R : Type ?u.152207
R' : Type ?u.152210
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
m : Set (Measure α)
h : ∀ (μ' : Measure α), μ' ∈ m → μ ≤ μ'
this : ↑μ ≤ sInf (toOuterMeasure '' m)
s : Set α
hs : MeasurableSet s
⊢ ↑↑μ s ≤ ↑(sInf (toOuterMeasure '' m)) s
Theorem: MeasureTheory.OuterMeasure.map_iSup
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp only [map_apply, iSup_apply]
state_before: α : Type u_3
β✝ : Type ?u.80158
R : Type ?u.80161
R' : Type ?u.80164
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
β : Type u_1
ι : Sort u_2
f : α → β
m : ι → OuterMeasure α
s : Set β
⊢ ↑(↑(map f) (⨆ (i : ι), m i)) s = ↑(⨆ (i : ι), ↑(map f) (m i)) s
Theorem: MeasureTheory.snorm_const_smul
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: obtain rfl | hc := eq_or_ne c 0
state_before: α : Type u_1
E : Type ?u.5983830
F : Type u_2
G : Type ?u.5983836
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
⊢ snorm (c • f) p μ = ↑‖c‖₊ * snorm f p μ

tactic: refine' le_antisymm (snorm_const_smul_le _ _) _
state_before: case inr
α : Type u_1
E : Type ?u.5983830
F : Type u_2
G : Type ?u.5983836
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
hc : c ≠ 0
⊢ snorm (c • f) p μ = ↑‖c‖₊ * snorm f p μ

tactic: have : snorm _ p μ ≤ _ := snorm_const_smul_le c⁻¹ (c • f)
state_before: case inr
α : Type u_1
E : Type ?u.5983830
F : Type u_2
G : Type ?u.5983836
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
hc : c ≠ 0
⊢ ↑‖c‖₊ * snorm f p μ ≤ snorm (c • f) p μ

tactic: rwa [inv_smul_smul₀ hc, nnnorm_inv, ENNReal.le_inv_smul_iff (nnnorm_ne_zero_iff.mpr hc)] at this
state_before: case inr
α : Type u_1
E : Type ?u.5983830
F : Type u_2
G : Type ?u.5983836
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
hc : c ≠ 0
this : snorm (c⁻¹ • c • f) p μ ≤ ‖c⁻¹‖₊ • snorm (c • f) p μ
⊢ ↑‖c‖₊ * snorm f p μ ≤ snorm (c • f) p μ

tactic: simp
state_before: case inl
α : Type u_1
E : Type ?u.5983830
F : Type u_2
G : Type ?u.5983836
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
f : α → F
⊢ snorm (0 • f) p μ = ↑‖0‖₊ * snorm f p μ
Theorem: Polynomial.splits_prod_iff
File: Mathlib/Data/Polynomial/Splits.lean

tactic: refine'
  Finset.induction_on t (fun _ =>
      ⟨fun _ _ h => by simp only [Finset.not_mem_empty] at h, fun _ => splits_one i⟩)
    fun a t hat ih ht => _
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
⊢ (∀ (j : ι), j ∈ t → s j ≠ 0) → (Splits i (∏ x in t, s x) ↔ ∀ (j : ι), j ∈ t → Splits i (s j))

tactic: rw [Finset.forall_mem_insert] at ht⊢
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : ¬a ∈ t
ih : (∀ (j : ι), j ∈ t → s j ≠ 0) → (Splits i (∏ x in t, s x) ↔ ∀ (j : ι), j ∈ t → Splits i (s j))
ht : ∀ (j : ι), j ∈ insert a t → s j ≠ 0
⊢ Splits i (∏ x in insert a t, s x) ↔ ∀ (j : ι), j ∈ insert a t → Splits i (s j)

tactic: rw [Finset.prod_insert hat, splits_mul_iff i ht.1 (Finset.prod_ne_zero_iff.2 ht.2), ih ht.2]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : ¬a ∈ t
ih : (∀ (j : ι), j ∈ t → s j ≠ 0) → (Splits i (∏ x in t, s x) ↔ ∀ (j : ι), j ∈ t → Splits i (s j))
ht : s a ≠ 0 ∧ ∀ (x : ι), x ∈ t → s x ≠ 0
⊢ Splits i (∏ x in insert a t, s x) ↔ Splits i (s a) ∧ ∀ (x : ι), x ∈ t → Splits i (s x)

tactic: simp only [Finset.not_mem_empty] at h
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
x✝² : ∀ (j : ι), j ∈ ∅ → s j ≠ 0
x✝¹ : Splits i (∏ x in ∅, s x)
x✝ : ι
h : x✝ ∈ ∅
⊢ Splits i (s x✝)
Theorem: Filter.HasBasis.eq_of_same_basis
File: Mathlib/Order/Filter/Bases.lean

tactic: ext t
state_before: α : Type u_1
β : Type ?u.11236
γ : Type ?u.11239
ι : Sort u_2
ι' : Sort ?u.11245
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
hl' : HasBasis l' p s
⊢ l = l'

tactic: rw [hl.mem_iff, hl'.mem_iff]
state_before: case a
α : Type u_1
β : Type ?u.11236
γ : Type ?u.11239
ι : Sort u_2
ι' : Sort ?u.11245
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
hl' : HasBasis l' p s
t : Set α
⊢ t ∈ l ↔ t ∈ l'
Theorem: String.Iterator.ValidFor.mk'
File: Std/Data/String/Lemmas.lean

tactic: simpa [List.reverseAux_eq] using mk
state_before: l r : List Char
⊢ ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
Theorem: ENNReal.ofReal_pos
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [ENNReal.ofReal]
state_before: α : Type ?u.807239
β : Type ?u.807242
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ
⊢ 0 < ENNReal.ofReal p ↔ 0 < p
Theorem: SubmodulesRingBasis.toRing_subgroups_basis
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

tactic: apply RingSubgroupsBasis.of_comm (fun i => (B i).toAddSubgroup) hB.inter hB.mul
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
B : ι → Submodule R A
hB✝ hB : SubmodulesRingBasis B
⊢ RingSubgroupsBasis fun i => Submodule.toAddSubgroup (B i)

tactic: intro a i
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
B : ι → Submodule R A
hB✝ hB : SubmodulesRingBasis B
⊢ ∀ (x : A) (i : ι), ∃ j, ↑(Submodule.toAddSubgroup (B j)) ⊆ (fun y => x * y) ⁻¹' ↑(Submodule.toAddSubgroup (B i))

tactic: rcases hB.leftMul a i with ⟨j, hj⟩
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
B : ι → Submodule R A
hB✝ hB : SubmodulesRingBasis B
a : A
i : ι
⊢ ∃ j, ↑(Submodule.toAddSubgroup (B j)) ⊆ (fun y => a * y) ⁻¹' ↑(Submodule.toAddSubgroup (B i))

tactic: use j
state_before: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
B : ι → Submodule R A
hB✝ hB : SubmodulesRingBasis B
a : A
i j : ι
hj : a • B j ≤ B i
⊢ ∃ j, ↑(Submodule.toAddSubgroup (B j)) ⊆ (fun y => a * y) ⁻¹' ↑(Submodule.toAddSubgroup (B i))

tactic: rintro b (b_in : b ∈ B j)
state_before: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
B : ι → Submodule R A
hB✝ hB : SubmodulesRingBasis B
a : A
i j : ι
hj : a • B j ≤ B i
⊢ ↑(Submodule.toAddSubgroup (B j)) ⊆ (fun y => a * y) ⁻¹' ↑(Submodule.toAddSubgroup (B i))

tactic: exact hj ⟨b, b_in, rfl⟩
state_before: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
B : ι → Submodule R A
hB✝ hB : SubmodulesRingBasis B
a : A
i j : ι
hj : a • B j ≤ B i
b : A
b_in : b ∈ B j
⊢ b ∈ (fun y => a * y) ⁻¹' ↑(Submodule.toAddSubgroup (B i))
Theorem: MvPolynomial.ext_iff
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [h]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ p q : MvPolynomial σ R
h : p = q
m : σ →₀ ℕ
⊢ coeff m p = coeff m q
Theorem: UniformGroup.mk'
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: simpa only [div_eq_mul_inv] using
h₁.comp (uniformContinuous_fst.prod_mk (h₂.comp uniformContinuous_snd))
state_before: α✝ : Type ?u.661
β : Type ?u.664
α : Type u_1
inst✝¹ : UniformSpace α
inst✝ : Group α
h₁ : UniformContinuous fun p => p.fst * p.snd
h₂ : UniformContinuous fun p => p⁻¹
⊢ UniformContinuous fun p => p.fst / p.snd
Theorem: mem_extChartAt_source
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: simp only [extChartAt_source, mem_chart_source]
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.184306
M' : Type ?u.184309
H' : Type ?u.184312
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
⊢ x ∈ (extChartAt I x).source
Theorem: sameRay_neg_iff
File: Mathlib/LinearAlgebra/Ray.lean

tactic: simp only [SameRay, neg_eq_zero, smul_neg, neg_inj]
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type ?u.141134
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
⊢ SameRay R (-x) (-y) ↔ SameRay R x y
Theorem: Seminorm.sub_mem_ball
File: Mathlib/Analysis/Seminorm.lean

tactic: simp_rw [mem_ball, sub_sub]
state_before: R : Type ?u.882649
R' : Type ?u.882652
𝕜 : Type u_1
𝕜₂ : Type ?u.882658
𝕜₃ : Type ?u.882661
𝕝 : Type ?u.882664
E : Type u_2
E₂ : Type ?u.882670
E₃ : Type ?u.882673
F : Type ?u.882676
G : Type ?u.882679
ι : Type ?u.882682
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y✝ : E
r✝ : ℝ
p : Seminorm 𝕜 E
x₁ x₂ y : E
r : ℝ
⊢ x₁ - x₂ ∈ ball p y r ↔ x₁ ∈ ball p (x₂ + y) r
Theorem: Multiset.lcm_dedup
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s : Multiset α
⊢ lcm (dedup 0) = lcm 0

tactic: by_cases h : a ∈ s <;> simp [IH, h]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : lcm (dedup s) = lcm s
⊢ lcm (dedup (a ::ₘ s)) = lcm (a ::ₘ s)

tactic: unfold lcm
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : lcm (dedup s) = lcm s
h : a ∈ s
⊢ lcm s = GCDMonoid.lcm a (lcm s)

tactic: rw [← cons_erase h, fold_cons_left, ← lcm_assoc, lcm_same]
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : lcm (dedup s) = lcm s
h : a ∈ s
⊢ fold GCDMonoid.lcm 1 s = GCDMonoid.lcm a (fold GCDMonoid.lcm 1 s)

tactic: apply lcm_eq_of_associated_left (associated_normalize _)
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : lcm (dedup s) = lcm s
h : a ∈ s
⊢ GCDMonoid.lcm a (fold GCDMonoid.lcm 1 (erase s a)) = GCDMonoid.lcm (↑normalize a) (fold GCDMonoid.lcm 1 (erase s a))
Theorem: not_fermat_4
File: Mathlib/NumberTheory/Fermat4.lean

tactic: intro heq
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
⊢ a ^ 4 + b ^ 4 ≠ c ^ 4

tactic: apply @not_fermat_42 _ _ (c ^ 2) ha hb
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 4
⊢ False

tactic: rw [heq]
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 4
⊢ a ^ 4 + b ^ 4 = (c ^ 2) ^ 2

tactic: ring
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
heq : a ^ 4 + b ^ 4 = c ^ 4
⊢ c ^ 4 = (c ^ 2) ^ 2
Theorem: Submonoid.fromLeftInv_mul
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: rw [mul_comm, mul_fromLeftInv]
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
x : { x // x ∈ leftInv S }
⊢ ↑(fromLeftInv S x) * ↑x = 1
Theorem: BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: simpa only [TaggedPrepartition.isPartition_iff_iUnion_eq, Prepartition.iUnion_top] using
  l.hasBasis_toFilteriUnion I ⊤
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
⊢ HasBasis (toFilteriUnion l I ⊤) (fun r => ∀ (c : ℝ≥0), RCond l (r c)) fun r =>
    {π | ∃ c, MemBaseSet l I c (r c) π ∧ IsPartition π}
Theorem: ChainComplex.of_d_ne
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [of]
state_before: ι : Type ?u.77771
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
α : Type u_1
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X (n + 1) ⟶ X n
sq : ∀ (n : α), d (n + 1) ≫ d n = 0
i j : α
h : i ≠ j + 1
⊢ HomologicalComplex.d (of X d sq) i j = 0

tactic: rw [dif_neg h]
state_before: ι : Type ?u.77771
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
α : Type u_1
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X (n + 1) ⟶ X n
sq : ∀ (n : α), d (n + 1) ≫ d n = 0
i j : α
h : i ≠ j + 1
⊢ (if h : i = j + 1 then eqToHom (_ : X i = X (j + 1)) ≫ d j else 0) = 0
Theorem: CircleDeg1Lift.lt_translationNumber_of_forall_add_lt
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: obtain ⟨x, -, hx⟩ : ∃ x ∈ Icc (0 : ℝ) 1, ∀ y ∈ Icc (0 : ℝ) 1, f x - x ≤ f y - y
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
⊢ z < τ f

tactic: exact isCompact_Icc.exists_forall_le (nonempty_Icc.2 zero_le_one)
  (hf.sub continuous_id).continuousOn
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
⊢ ∃ x, x ∈ Icc 0 1 ∧ ∀ (y : ℝ), y ∈ Icc 0 1 → ↑f x - x ≤ ↑f y - y

case intro.intro
f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
x : ℝ
hx : ∀ (y : ℝ), y ∈ Icc 0 1 → ↑f x - x ≤ ↑f y - y
⊢ z < τ f

tactic: refine' lt_of_lt_of_le (lt_sub_iff_add_lt'.2 <| hz x) _
state_before: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
x : ℝ
hx : ∀ (y : ℝ), y ∈ Icc 0 1 → ↑f x - x ≤ ↑f y - y
⊢ z < τ f

tactic: apply le_translationNumber_of_add_le
state_before: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
x : ℝ
hx : ∀ (y : ℝ), y ∈ Icc 0 1 → ↑f x - x ≤ ↑f y - y
⊢ ↑f x - x ≤ τ f

tactic: simp only [← le_sub_iff_add_le']
state_before: case intro.intro.hz
f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
x : ℝ
hx : ∀ (y : ℝ), y ∈ Icc 0 1 → ↑f x - x ≤ ↑f y - y
⊢ ∀ (x_1 : ℝ), x_1 + (↑f x - x) ≤ ↑f x_1

tactic: exact f.forall_map_sub_of_Icc _ hx
state_before: case intro.intro.hz
f g : CircleDeg1Lift
hf : Continuous ↑f
z : ℝ
hz : ∀ (x : ℝ), x + z < ↑f x
x : ℝ
hx : ∀ (y : ℝ), y ∈ Icc 0 1 → ↑f x - x ≤ ↑f y - y
⊢ ∀ (x_1 : ℝ), ↑f x - x ≤ ↑f x_1 - x_1