1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: RatFunc.denom_dvd
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: constructor
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ x.denom ∣ q ↔ ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
state_after: case mp
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ x.denom ∣ q → ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q

case mpr
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ (∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) → x.denom ∣ q

tactic: rintro ⟨p, rfl⟩
state_before: case mp
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ x.denom ∣ q → ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
state_after: case mp.intro
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
⊢ ∃ p_1, x = (algebraMap K[X] (RatFunc K)) p_1 / (algebraMap K[X] (RatFunc K)) (x.denom * p)

tactic: obtain ⟨_hx, hp⟩ := mul_ne_zero_iff.mp hq
state_before: case mp.intro
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
⊢ ∃ p_1, x = (algebraMap K[X] (RatFunc K)) p_1 / (algebraMap K[X] (RatFunc K)) (x.denom * p)
state_after: case mp.intro.intro
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
_hx : x.denom ≠ 0
hp : p ≠ 0
⊢ ∃ p_1, x = (algebraMap K[X] (RatFunc K)) p_1 / (algebraMap K[X] (RatFunc K)) (x.denom * p)

tactic: use num x * p
state_before: case mp.intro.intro
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
_hx : x.denom ≠ 0
hp : p ≠ 0
⊢ ∃ p_1, x = (algebraMap K[X] (RatFunc K)) p_1 / (algebraMap K[X] (RatFunc K)) (x.denom * p)
state_after: case h
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
_hx : x.denom ≠ 0
hp : p ≠ 0
⊢ x = (algebraMap K[X] (RatFunc K)) (x.num * p) / (algebraMap K[X] (RatFunc K)) (x.denom * p)

tactic: rw [RingHom.map_mul, RingHom.map_mul, ← div_mul_div_comm, div_self, mul_one, num_div_denom]
state_before: case h
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
_hx : x.denom ≠ 0
hp : p ≠ 0
⊢ x = (algebraMap K[X] (RatFunc K)) (x.num * p) / (algebraMap K[X] (RatFunc K)) (x.denom * p)
state_after: case h
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
_hx : x.denom ≠ 0
hp : p ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) p ≠ 0

tactic: exact algebraMap_ne_zero hp
state_before: case h
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hq : x.denom * p ≠ 0
_hx : x.denom ≠ 0
hp : p ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) p ≠ 0
state_after: no goals

tactic: rintro ⟨p, rfl⟩
state_before: case mpr
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ (∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) → x.denom ∣ q
state_after: case mpr.intro
K : Type u
inst✝ : Field K
q : K[X]
hq : q ≠ 0
p : K[X]
⊢ ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom ∣ q

tactic: exact denom_div_dvd p q
state_before: case mpr.intro
K : Type u
inst✝ : Field K
q : K[X]
hq : q ≠ 0
p : K[X]
⊢ ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom ∣ q
state_after: no goals
Theorem: LinearMap.annihilator_le_of_injective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [Module.mem_annihilator] at h ⊢
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : R
h : x ∈ Module.annihilator R M'
⊢ x ∈ Module.annihilator R M
state_after: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : R
h : ∀ (m : M'), x • m = 0
⊢ ∀ (m : M), x • m = 0

tactic: exact fun m ↦ hf (by rw [map_smul, h, f.map_zero])
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : R
h : ∀ (m : M'), x • m = 0
⊢ ∀ (m : M), x • m = 0
state_after: no goals

tactic: rw [map_smul, h, f.map_zero]
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : R
h : ∀ (m : M'), x • m = 0
m : M
⊢ f (x • m) = f 0
state_after: no goals
Theorem: Equiv.Perm.support_congr
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: ext x
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
⊢ f = g
state_after: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
⊢ f x = g x

tactic: by_cases hx : x ∈ g.support
state_before: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
⊢ f x = g x
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∈ g.support
⊢ f x = g x

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∉ g.support
⊢ f x = g x

tactic: exact h' x hx
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∈ g.support
⊢ f x = g x
state_after: no goals

tactic: rw [not_mem_support.mp hx, ← not_mem_support]
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∉ g.support
⊢ f x = g x
state_after: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∉ g.support
⊢ x ∉ f.support

tactic: exact fun H => hx (h H)
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.support ⊆ g.support
h' : ∀ x ∈ g.support, f x = g x
x : α
hx : x ∉ g.support
⊢ x ∉ f.support
state_after: no goals
Theorem: MeasureTheory.setLIntegral_congr
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [Measure.restrict_congr_set h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s t : Set α
h : s =ᶠ[ae μ] t
⊢ ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in t, f x ∂μ
state_after: no goals
Theorem: Vector.mapAccumr₂_mapAccumr₂_left_right
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
γ σ₁ φ σ₂ : Type
s₂ : σ₂
s₁ : σ₁
f₁ : γ → β → σ₁ → σ₁ × φ
f₂ : α → β → σ₂ → σ₂ × γ
⊢ mapAccumr₂ f₁ (mapAccumr₂ f₂ xs ys s₂).2 ys s₁ =
    let m :=
      mapAccumr₂
        (fun x y x_1 =>
          match x_1 with
          | (s₁, s₂) =>
            let r₂ := f₂ x y s₂;
            let r₁ := f₁ r₂.2 y s₁;
            ((r₁.1, r₂.1), r₁.2))
        xs ys (s₁, s₂);
    (m.1.1, m.2)
state_after: no goals
Theorem: List.Pairwise.pmap
File: Mathlib/Data/List/Pairwise.lean

tactic: refine (pairwise_pmap h).2 (Pairwise.imp_of_mem ?_ hl)
state_before: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
⊢ Pairwise S (List.pmap f l h)
state_after: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
⊢ ∀ {a b : α}, a ∈ l → b ∈ l → R a b → ∀ (h₁ : p a) (h₂ : p b), S (f a h₁) (f b h₂)

tactic: intros
state_before: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
⊢ ∀ {a b : α}, a ∈ l → b ∈ l → R a b → ∀ (h₁ : p a) (h₂ : p b), S (f a h₁) (f b h₂)
state_after: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
a✝³ b✝ : α
a✝² : a✝³ ∈ l
a✝¹ : b✝ ∈ l
a✝ : R a✝³ b✝
h₁✝ : p a✝³
h₂✝ : p b✝
⊢ S (f a✝³ h₁✝) (f b✝ h₂✝)

tactic: apply hS
state_before: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
a✝³ b✝ : α
a✝² : a✝³ ∈ l
a✝¹ : b✝ ∈ l
a✝ : R a✝³ b✝
h₁✝ : p a✝³
h₂✝ : p b✝
⊢ S (f a✝³ h₁✝) (f b✝ h₂✝)
state_after: case a
α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
a✝³ b✝ : α
a✝² : a✝³ ∈ l
a✝¹ : b✝ ∈ l
a✝ : R a✝³ b✝
h₁✝ : p a✝³
h₂✝ : p b✝
⊢ R a✝³ b✝

tactic: assumption
state_before: case a
α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
a✝³ b✝ : α
a✝² : a✝³ ∈ l
a✝¹ : b✝ ∈ l
a✝ : R a✝³ b✝
h₁✝ : p a✝³
h₂✝ : p b✝
⊢ R a✝³ b✝
state_after: no goals
Theorem: CategoryTheory.Limits.kernelSubobject_arrow'
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [kernelSubobjectIso]
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
⊢ (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow = kernel.ι f
state_after: no goals
Theorem: SimpleGraph.Walk.map_eq_nil_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p✝ : G.Walk u v
p : G.Walk u u
⊢ Walk.map f p = nil ↔ p = nil
state_after: no goals
Theorem: CategoryTheory.Limits.cospanExt_inv_app_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.one = iZ.inv
state_after: no goals
Theorem: ENNReal.tendsto_sum_nat_add
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to ℕ → ℝ≥0 using ENNReal.ne_top_of_tsum_ne_top hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0∞
hf : ∑' (i : ℕ), f i ≠ ⊤
⊢ Tendsto (fun i => ∑' (k : ℕ), f (k + i)) atTop (𝓝 0)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hf : ∑' (i : ℕ), (fun i => ↑(f i)) i ≠ ⊤
⊢ Tendsto (fun i => ∑' (k : ℕ), (fun i => ↑(f i)) (k + i)) atTop (𝓝 0)

tactic: replace hf : Summable f := tsum_coe_ne_top_iff_summable.1 hf
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hf : ∑' (i : ℕ), (fun i => ↑(f i)) i ≠ ⊤
⊢ Tendsto (fun i => ∑' (k : ℕ), (fun i => ↑(f i)) (k + i)) atTop (𝓝 0)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hf : Summable f
⊢ Tendsto (fun i => ∑' (k : ℕ), (fun i => ↑(f i)) (k + i)) atTop (𝓝 0)

tactic: simp only [← ENNReal.coe_tsum, NNReal.summable_nat_add _ hf, ← ENNReal.coe_zero]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hf : Summable f
⊢ Tendsto (fun i => ∑' (k : ℕ), (fun i => ↑(f i)) (k + i)) atTop (𝓝 0)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hf : Summable f
⊢ Tendsto (fun i => ↑(∑' (a : ℕ), f (a + i))) atTop (𝓝 ↑0)

tactic: exact mod_cast NNReal.tendsto_sum_nat_add f
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
hf : Summable f
⊢ Tendsto (fun i => ↑(∑' (a : ℕ), f (a + i))) atTop (𝓝 ↑0)
state_after: no goals
Theorem: List.getElem_iterate
File: Mathlib/Data/List/Iterate.lean

tactic: simpa using h
state_before: α : Type u_1
f : α → α
a : α
n i : ℕ
h : i < (iterate f a n).length
⊢ i < n
state_after: no goals
Theorem: BoxIntegral.Box.coe_ae_eq_Icc
File: Mathlib/Analysis/BoxIntegral/Partition/Measure.lean

tactic: rw [coe_eq_pi]
state_before: ι : Type u_1
I : Box ι
inst✝ : Fintype ι
⊢ ↑I =ᶠ[ae volume] Box.Icc I
state_after: ι : Type u_1
I : Box ι
inst✝ : Fintype ι
⊢ (univ.pi fun i => Ioc (I.lower i) (I.upper i)) =ᶠ[ae volume] Box.Icc I

tactic: exact Measure.univ_pi_Ioc_ae_eq_Icc
state_before: ι : Type u_1
I : Box ι
inst✝ : Fintype ι
⊢ (univ.pi fun i => Ioc (I.lower i) (I.upper i)) =ᶠ[ae volume] Box.Icc I
state_after: no goals
Theorem: Polynomial.natDegree_sub_le_iff_left
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

tactic: rw [← natDegree_neg] at qn
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
qn : q.natDegree ≤ n
⊢ (p - q).natDegree ≤ n ↔ p.natDegree ≤ n
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
qn : (-q).natDegree ≤ n
⊢ (p - q).natDegree ≤ n ↔ p.natDegree ≤ n

tactic: rw [sub_eq_add_neg, natDegree_add_le_iff_left _ _ qn]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
qn : (-q).natDegree ≤ n
⊢ (p - q).natDegree ≤ n ↔ p.natDegree ≤ n
state_after: no goals
Theorem: Filter.tendsto_iff_ptendsto
File: Mathlib/Order/Filter/Partial.lean

tactic: simp only [Tendsto, PTendsto, pmap_res]
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
s : Set α
f : α → β
⊢ Tendsto f (l₁ ⊓ 𝓟 s) l₂ ↔ PTendsto (PFun.res f s) l₁ l₂
state_after: no goals
Theorem: rpow_mul_exp_neg_mul_rpow_isLittleO_exp_neg
File: Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean

tactic: apply ((isBigO_refl (fun x : ℝ => x ^ s) atTop).mul_isLittleO
    (exp_neg_mul_rpow_isLittleO_exp_neg hb hp)).trans
state_before: s b p : ℝ
hp : 1 < p
hb : 0 < b
⊢ (fun x => x ^ s * rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-(1 / 2) * x)
state_after: s b p : ℝ
hp : 1 < p
hb : 0 < b
⊢ (fun x => x ^ s * rexp (-x)) =o[atTop] fun x => rexp (-(1 / 2) * x)

tactic: simpa only [mul_comm] using Real.Gamma_integrand_isLittleO s
state_before: s b p : ℝ
hp : 1 < p
hb : 0 < b
⊢ (fun x => x ^ s * rexp (-x)) =o[atTop] fun x => rexp (-(1 / 2) * x)
state_after: no goals
Theorem: IntermediateField.restrictScalars_adjoin
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [← adjoin_self _ K, adjoin_adjoin_left, adjoin_self _ K]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
K : IntermediateField F E
S : Set E
⊢ restrictScalars F (adjoin (↥K) S) = adjoin F (↑K ∪ S)
state_after: no goals
Theorem: RingHom.map_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [Matrix.mulVec, Matrix.map_apply, RingHom.map_dotProduct, Function.comp]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : Fintype n
inst✝³ : NonAssocSemiring α
inst✝² : NonAssocSemiring β
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f : R →+* S
M : Matrix m n R
v : n → R
i : m
⊢ f ((M *ᵥ v) i) = (M.map ⇑f *ᵥ ⇑f ∘ v) i
state_after: no goals
Theorem: AkraBazziRecurrence.eventually_deriv_one_add_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: filter_upwards [eventually_gt_atTop 1] with x hx
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ (deriv fun x => 1 + ε x) =ᶠ[atTop] deriv ε
state_after: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 + ε x) x = deriv ε x

tactic: rw [deriv_add] <;> aesop
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 + ε x) x = deriv ε x
state_after: no goals

tactic: filter_upwards [eventually_gt_atTop 1] with x hx
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ deriv ε =ᶠ[atTop] fun x => -x⁻¹ / log x ^ 2
state_after: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv ε x = -x⁻¹ / log x ^ 2

tactic: simp [deriv_smoothingFn hx]
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv ε x = -x⁻¹ / log x ^ 2
state_after: no goals
Theorem: PartENat.le_of_lt_add_one
File: Mathlib/Data/Nat/PartENat.lean

tactic: induction' y using PartENat.casesOn with n
state_before: x y : PartENat
h : x < y + 1
⊢ x ≤ y
state_after: case a
x : PartENat
h : x < ⊤ + 1
⊢ x ≤ ⊤

case a
x : PartENat
n : ℕ
h : x < ↑n + 1
⊢ x ≤ ↑n

tactic: rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
state_before: case a
x : PartENat
n : ℕ
h : x < ↑n + 1
⊢ x ≤ ↑n
state_after: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ ↑m ≤ ↑n

tactic: norm_cast
state_before: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ ↑m ≤ ↑n
state_after: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ m ≤ n

tactic: apply Nat.le_of_lt_succ
state_before: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ m ≤ n
state_after: case a.intro.a
n m : ℕ
h : ↑m < ↑n + 1
⊢ m < n.succ

tactic: norm_cast at h
state_before: case a.intro.a
n m : ℕ
h : ↑m < ↑n + 1
⊢ m < n.succ
state_after: no goals

tactic: apply le_top
state_before: case a
x : PartENat
h : x < ⊤ + 1
⊢ x ≤ ⊤
state_after: no goals
Theorem: unitInterval.symm_zero
File: Mathlib/Topology/UnitInterval.lean

tactic: simp [symm]
state_before: ⊢ ↑(σ 0) = ↑1
state_after: no goals
Theorem: IsRightRegular.left_of_commute
File: Mathlib/Algebra/Regular/Basic.lean

tactic: simp_rw [@Commute.symm_iff R _ a] at ca
state_before: R : Type u_1
inst✝ : Mul R
a : R
ca : ∀ (b : R), Commute a b
h : IsRightRegular a
⊢ IsLeftRegular a
state_after: R : Type u_1
inst✝ : Mul R
a : R
h : IsRightRegular a
ca : ∀ (b : R), Commute b a
⊢ IsLeftRegular a

tactic: exact fun x y xy => h <| (ca x).trans <| xy.trans <| (ca y).symm
state_before: R : Type u_1
inst✝ : Mul R
a : R
h : IsRightRegular a
ca : ∀ (b : R), Commute b a
⊢ IsLeftRegular a
state_after: no goals
Theorem: Finset.smul_finset_neg
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp only [← image_smul, ← image_neg, Function.comp, image_image, smul_neg]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Monoid α
inst✝² : AddGroup β
inst✝¹ : DistribMulAction α β
inst✝ : DecidableEq β
a : α
s : Finset α
t : Finset β
⊢ a • -t = -(a • t)
state_after: no goals
Theorem: RCLike.re_eq_norm_of_mul_conj
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [mul_conj, ← ofReal_pow]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
⊢ re (x * (starRingEnd K) x) = ‖x * (starRingEnd K) x‖
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
⊢ re ↑(‖x‖ ^ 2) = ‖↑(‖x‖ ^ 2)‖

tactic: simp [-ofReal_pow]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
⊢ re ↑(‖x‖ ^ 2) = ‖↑(‖x‖ ^ 2)‖
state_after: no goals
Theorem: EuclideanGeometry.oangle_right_eq_arcsin_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: have hs : (∡ p₂ p₃ p₁).sign = 1 := by rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ ∡ p₂ p₃ p₁ = ↑(Real.arcsin (dist p₁ p₂ / dist p₁ p₃))
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ ∡ p₂ p₃ p₁ = ↑(Real.arcsin (dist p₁ p₂ / dist p₁ p₃))

tactic: rw [oangle_eq_angle_of_sign_eq_one hs,
  angle_eq_arcsin_of_angle_eq_pi_div_two (angle_eq_pi_div_two_of_oangle_eq_pi_div_two h)
    (Or.inl (left_ne_of_oangle_eq_pi_div_two h))]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ ∡ p₂ p₃ p₁ = ↑(Real.arcsin (dist p₁ p₂ / dist p₁ p₃))
state_after: no goals

tactic: rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ (∡ p₂ p₃ p₁).sign = 1
state_after: no goals
Theorem: Nat.one_div_le_one_div
File: Mathlib/Data/Nat/Cast/Field.lean

tactic: refine one_div_le_one_div_of_le ?_ ?_
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 1 / (↑m + 1) ≤ 1 / (↑n + 1)
state_after: case refine_1
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 0 < ↑n + 1

case refine_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ ↑n + 1 ≤ ↑m + 1

tactic: exact Nat.cast_add_one_pos _
state_before: case refine_1
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 0 < ↑n + 1
state_after: no goals

tactic: simpa
state_before: case refine_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ ↑n + 1 ≤ ↑m + 1
state_after: no goals
Theorem: EReal.strictMono_div_right_of_pos
File: Mathlib/Data/Real/EReal.lean

tactic: intro a a' a_lt_a'
state_before: b : EReal
h : 0 < b
h' : b ≠ ⊤
⊢ StrictMono fun a => a / b
state_after: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
⊢ (fun a => a / b) a < (fun a => a / b) a'

tactic: apply lt_of_le_of_ne <| div_le_div_right_of_nonneg (le_of_lt h) (le_of_lt a_lt_a')
state_before: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
⊢ (fun a => a / b) a < (fun a => a / b) a'
state_after: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
⊢ a / b ≠ a' / b

tactic: intro hyp
state_before: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
⊢ a / b ≠ a' / b
state_after: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
hyp : a / b = a' / b
⊢ False

tactic: apply ne_of_lt a_lt_a'
state_before: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
hyp : a / b = a' / b
⊢ False
state_after: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
hyp : a / b = a' / b
⊢ a = a'

tactic: rw [← @EReal.mul_div_cancel a b (ne_bot_of_gt h) h' (ne_of_gt h), hyp,
  @EReal.mul_div_cancel a' b (ne_bot_of_gt h) h' (ne_of_gt h)]
state_before: b : EReal
h : 0 < b
h' : b ≠ ⊤
a a' : EReal
a_lt_a' : a < a'
hyp : a / b = a' / b
⊢ a = a'
state_after: no goals
Theorem: sq_lt_one_iff_abs_lt_one
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: simpa only [one_pow, abs_one] using @sq_lt_sq _ _ a 1
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a✝ b c a : α
⊢ a ^ 2 < 1 ↔ |a| < 1
state_after: no goals