1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: GeneralizedContinuedFraction.continuants_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

tactic: simp only [nth_cont_eq_succ_nth_cont_aux,
  continuantsAux_stable_of_terminated (Nat.pred_le_iff.mp n_le_m) terminated_at_n]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
n_le_m : n ≤ m
terminated_at_n : g.TerminatedAt n
⊢ g.continuants m = g.continuants n
state_after: no goals
Theorem: Finset.coe_filterMap
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [mem_coe, mem_filterMap, Option.mem_def, Set.mem_setOf_eq, implies_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
s' s t : Finset α
f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'
⊢ ∀ (x : β), x ∈ ↑(filterMap f s f_inj) ↔ x ∈ {b | ∃ a ∈ s, f a = some b}
state_after: no goals
Theorem: EuclideanGeometry.Sphere.inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center
File: Mathlib/Geometry/Euclidean/Angle/Sphere.lean

tactic: convert tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center hp₁ hp₃ hp₁p₃
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)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₁p₂ : p₁ ≠ p₂
hp₁p₃ : p₁ ≠ p₃
hp₂p₃ : p₂ ≠ p₃
⊢ ((∡ p₁ p₂ p₃).tan⁻¹ / 2) • (o.rotation ↑(π / 2)) (p₃ -ᵥ p₁) +ᵥ midpoint ℝ p₁ p₃ = s.center
state_after: case h.e'_2.h.e'_5.h.e'_5.h.e'_5
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)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₁p₂ : p₁ ≠ p₂
hp₁p₃ : p₁ ≠ p₃
hp₂p₃ : p₂ ≠ p₃
⊢ (∡ p₁ p₂ p₃).tan⁻¹ = (∡ p₃ p₁ s.center).tan

tactic: convert (Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi _).symm
state_before: case h.e'_2.h.e'_5.h.e'_5.h.e'_5
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)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₁p₂ : p₁ ≠ p₂
hp₁p₃ : p₁ ≠ p₃
hp₂p₃ : p₂ ≠ p₃
⊢ (∡ p₁ p₂ p₃).tan⁻¹ = (∡ p₃ p₁ s.center).tan
state_after: case h.e'_2.h.e'_5.h.e'_5.h.e'_5.convert_3
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)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₁p₂ : p₁ ≠ p₂
hp₁p₃ : p₁ ≠ p₃
hp₂p₃ : p₂ ≠ p₃
⊢ 2 • ∡ p₁ p₂ p₃ + 2 • ∡ p₃ p₁ s.center = ↑π

tactic: rw [add_comm,
  two_zsmul_oangle_center_add_two_zsmul_oangle_eq_pi hp₁ hp₂ hp₃ hp₁p₂.symm hp₂p₃ hp₁p₃]
state_before: case h.e'_2.h.e'_5.h.e'_5.h.e'_5.convert_3
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)
s : Sphere P
p₁ p₂ p₃ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₁p₂ : p₁ ≠ p₂
hp₁p₃ : p₁ ≠ p₃
hp₂p₃ : p₂ ≠ p₃
⊢ 2 • ∡ p₁ p₂ p₃ + 2 • ∡ p₃ p₁ s.center = ↑π
state_after: no goals
Theorem: CategoryTheory.Functor.commShiftIso_comp_inv_app
File: Mathlib/CategoryTheory/Shift/CommShift.lean

tactic: simp [commShiftIso, CommShift.iso]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹¹ : Category.{u_6, u_1} C
inst✝¹⁰ : Category.{u_7, u_2} D
inst✝⁹ : Category.{u_8, u_3} E
F : C ⥤ D
G : D ⥤ E
A : Type u_4
B : Type u_5
inst✝⁸ : AddMonoid A
inst✝⁷ : AddCommMonoid B
inst✝⁶ : HasShift C A
inst✝⁵ : HasShift D A
inst✝⁴ : HasShift E A
inst✝³ : HasShift C B
inst✝² : HasShift D B
inst✝¹ : F.CommShift A
inst✝ : G.CommShift A
a : A
X : C
⊢ ((F ⋙ G).commShiftIso a).inv.app X = (G.commShiftIso a).inv.app (F.obj X) ≫ G.map ((F.commShiftIso a).inv.app X)
state_after: no goals
Theorem: Con.mapOfSurjective_eq_mapGen
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: rw [← conGen_of_con (c.mapOfSurjective f H h hf)]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ c.mapGen f = c.mapOfSurjective f H h hf
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ c.mapGen f = conGen ⇑(c.mapOfSurjective f H h hf)

tactic: rfl
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c : Con M
f : M → N
H : ∀ (x y : M), f (x * y) = f x * f y
h : mulKer f H ≤ c
hf : Surjective f
⊢ c.mapGen f = conGen ⇑(c.mapOfSurjective f H h hf)
state_after: no goals
Theorem: List.findIdx?_append
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction xs with simp
| cons _ _ _ => split <;> simp_all [Option.map_orElse, Option.map_map]; rfl
state_before: α : Type u_1
xs ys : List α
p : α → Bool
⊢ findIdx? p (xs ++ ys) = HOrElse.hOrElse (findIdx? p xs) fun x => Option.map (fun i => i + xs.length) (findIdx? p ys)
state_after: no goals

tactic: split <;> simp_all [Option.map_orElse, Option.map_map]
state_before: case cons
α : Type u_1
ys : List α
p : α → Bool
head✝ : α
tail✝ : List α
tail_ih✝ :
  findIdx? p (tail✝ ++ ys) =
    HOrElse.hOrElse (findIdx? p tail✝) fun x => Option.map (fun i => i + tail✝.length) (findIdx? p ys)
⊢ (if p head✝ = true then some 0 else Option.map (fun i => i + 1) (findIdx? p (tail✝ ++ ys))) =
    HOrElse.hOrElse (if p head✝ = true then some 0 else Option.map (fun i => i + 1) (findIdx? p tail✝)) fun x =>
      Option.map (fun i => i + (tail✝.length + 1)) (findIdx? p ys)
state_after: case cons.isFalse
α : Type u_1
ys : List α
p : α → Bool
head✝ : α
tail✝ : List α
tail_ih✝ :
  findIdx? p (tail✝ ++ ys) =
    HOrElse.hOrElse (findIdx? p tail✝) fun x => Option.map (fun i => i + tail✝.length) (findIdx? p ys)
h✝ : p head✝ = false
⊢ (HOrElse.hOrElse (Option.map (fun i => i + 1) (findIdx? p tail✝)) fun x =>
      Option.map ((fun i => i + 1) ∘ fun i => i + tail✝.length) (findIdx? p ys)) =
    HOrElse.hOrElse (Option.map (fun i => i + 1) (findIdx? p tail✝)) fun x =>
      Option.map (fun i => i + (tail✝.length + 1)) (findIdx? p ys)

tactic: rfl
state_before: case cons.isFalse
α : Type u_1
ys : List α
p : α → Bool
head✝ : α
tail✝ : List α
tail_ih✝ :
  findIdx? p (tail✝ ++ ys) =
    HOrElse.hOrElse (findIdx? p tail✝) fun x => Option.map (fun i => i + tail✝.length) (findIdx? p ys)
h✝ : p head✝ = false
⊢ (HOrElse.hOrElse (Option.map (fun i => i + 1) (findIdx? p tail✝)) fun x =>
      Option.map ((fun i => i + 1) ∘ fun i => i + tail✝.length) (findIdx? p ys)) =
    HOrElse.hOrElse (Option.map (fun i => i + 1) (findIdx? p tail✝)) fun x =>
      Option.map (fun i => i + (tail✝.length + 1)) (findIdx? p ys)
state_after: no goals
Theorem: Finset.map_add_right_Ioc
File: Mathlib/Algebra/Order/Interval/Finset.lean

tactic: rw [← coe_inj, coe_map, coe_Ioc, coe_Ioc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Ioc a b) = Ioc (a + c) (b + c)
state_after: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Ioc a b = Set.Ioc (a + c) (b + c)

tactic: exact Set.image_add_const_Ioc _ _ _
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Ioc a b = Set.Ioc (a + c) (b + c)
state_after: no goals
Theorem: Finset.centroid_map
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [centroid_def, affineCombination_map, centroidWeights]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
e : ι₂ ↪ ι
p : ι → P
⊢ centroid k (map e s₂) p = centroid k s₂ (p ∘ ⇑e)
state_after: no goals
Theorem: normalize_eq_zero
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
x : α
⊢ x = 0 → normalize x = 0
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
⊢ normalize 0 = 0

tactic: exact normalize_zero
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
⊢ normalize 0 = 0
state_after: no goals
Theorem: IsUnit.mul_inv_cancel
File: Mathlib/Algebra/Group/Units.lean

tactic: rintro ⟨u, rfl⟩
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
⊢ IsUnit a → a * a⁻¹ = 1
state_after: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ ↑u * (↑u)⁻¹ = 1

tactic: rw [← Units.val_inv_eq_inv_val, Units.mul_inv]
state_before: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ ↑u * (↑u)⁻¹ = 1
state_after: no goals
Theorem: NormedField.tendsto_norm_zpow_nhdsWithin_0_atTop
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rcases neg_surjective m with ⟨m, rfl⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℤ
hm : m < 0
⊢ Tendsto (fun x => ‖x ^ m‖) (𝓝[≠] 0) atTop
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℤ
hm : -m < 0
⊢ Tendsto (fun x => ‖x ^ (-m)‖) (𝓝[≠] 0) atTop

tactic: rw [neg_lt_zero] at hm
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℤ
hm : -m < 0
⊢ Tendsto (fun x => ‖x ^ (-m)‖) (𝓝[≠] 0) atTop
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℤ
hm : 0 < m
⊢ Tendsto (fun x => ‖x ^ (-m)‖) (𝓝[≠] 0) atTop

tactic: lift m to ℕ using hm.le
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℤ
hm : 0 < m
⊢ Tendsto (fun x => ‖x ^ (-m)‖) (𝓝[≠] 0) atTop
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℕ
hm : 0 < ↑m
⊢ Tendsto (fun x => ‖x ^ (-↑m)‖) (𝓝[≠] 0) atTop

tactic: rw [Int.natCast_pos] at hm
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℕ
hm : 0 < ↑m
⊢ Tendsto (fun x => ‖x ^ (-↑m)‖) (𝓝[≠] 0) atTop
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℕ
hm : 0 < m
⊢ Tendsto (fun x => ‖x ^ (-↑m)‖) (𝓝[≠] 0) atTop

tactic: simp only [norm_pow, zpow_neg, zpow_natCast, ← inv_pow]
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℕ
hm : 0 < m
⊢ Tendsto (fun x => ‖x ^ (-↑m)‖) (𝓝[≠] 0) atTop
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℕ
hm : 0 < m
⊢ Tendsto (fun x => ‖x⁻¹‖ ^ m) (𝓝[≠] 0) atTop

tactic: exact (tendsto_pow_atTop hm.ne').comp NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NormedDivisionRing 𝕜
m : ℕ
hm : 0 < m
⊢ Tendsto (fun x => ‖x⁻¹‖ ^ m) (𝓝[≠] 0) atTop
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.comp
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rw [← map_map hg.1 hf.1, hf.2, hg.2]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : β → γ
f : α → β
hg : MeasurePreserving g μb μc
hf : MeasurePreserving f μa μb
⊢ map (g ∘ f) μa = μc
state_after: no goals
Theorem: MvPolynomial.vars_add_subset
File: Mathlib/Algebra/MvPolynomial/Variables.lean

tactic: intro x hx
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ (p + q).vars ⊆ p.vars ∪ q.vars
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
x : σ
hx : x ∈ (p + q).vars
⊢ x ∈ p.vars ∪ q.vars

tactic: simp only [vars_def, Finset.mem_union, Multiset.mem_toFinset] at hx ⊢
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
x : σ
hx : x ∈ (p + q).vars
⊢ x ∈ p.vars ∪ q.vars
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
x : σ
hx : x ∈ (p + q).degrees
⊢ x ∈ p.degrees ∨ x ∈ q.degrees

tactic: simpa using Multiset.mem_of_le (degrees_add _ _) hx
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
x : σ
hx : x ∈ (p + q).degrees
⊢ x ∈ p.degrees ∨ x ∈ q.degrees
state_after: no goals
Theorem: RCLike.abs_im_div_norm_le_one
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [abs_div, abs_norm]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ |im z / ‖z‖| ≤ 1
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ |im z| / ‖z‖ ≤ 1

tactic: exact div_le_one_of_le (abs_im_le_norm _) (norm_nonneg _)
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ |im z| / ‖z‖ ≤ 1
state_after: no goals
Theorem: HasFDerivAt.iterate
File: Mathlib/Analysis/Calculus/FDeriv/Comp.lean

tactic: refine HasFDerivAtFilter.iterate hf ?_ hx n
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivAt f f' x
hx : f x = x
n : ℕ
⊢ HasFDerivAt f^[n] (f' ^ n) x
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivAt f f' x
hx : f x = x
n : ℕ
⊢ Tendsto f (𝓝 x) (𝓝 x)

tactic: convert hf.continuousAt.tendsto
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivAt f f' x
hx : f x = x
n : ℕ
⊢ Tendsto f (𝓝 x) (𝓝 x)
state_after: case h.e'_5.h.e'_3
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivAt f f' x
hx : f x = x
n : ℕ
⊢ x = f x

tactic: exact hx.symm
state_before: case h.e'_5.h.e'_3
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivAt f f' x
hx : f x = x
n : ℕ
⊢ x = f x
state_after: no goals
Theorem: ComplexShape.σ_symm
File: Mathlib/Algebra/Homology/ComplexShapeSigns.lean

tactic: apply TotalComplexShapeSymmetrySymmetry.σ_symm
state_before: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝⁴ : TotalComplexShape c₁ c₂ c₁₂
inst✝³ : TotalComplexShape c₂ c₁ c₁₂
inst✝² : TotalComplexShapeSymmetry c₁ c₂ c₁₂
inst✝¹ : TotalComplexShapeSymmetry c₂ c₁ c₁₂
inst✝ : TotalComplexShapeSymmetrySymmetry c₁ c₂ c₁₂
i₁ : I₁
i₂ : I₂
⊢ c₂.σ c₁ c₁₂ i₂ i₁ = c₁.σ c₂ c₁₂ i₁ i₂
state_after: no goals
Theorem: StrictMono.prod_map
File: Mathlib/Order/Monotone/Basic.lean

tactic: simp only [Prod.lt_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictMono f
hg : StrictMono g
a b : α × β
⊢ a < b → Prod.map f g a < Prod.map f g b
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictMono f
hg : StrictMono g
a b : α × β
⊢ a.1 < b.1 ∧ a.2 ≤ b.2 ∨ a.1 ≤ b.1 ∧ a.2 < b.2 →
    (Prod.map f g a).1 < (Prod.map f g b).1 ∧ (Prod.map f g a).2 ≤ (Prod.map f g b).2 ∨
      (Prod.map f g a).1 ≤ (Prod.map f g b).1 ∧ (Prod.map f g a).2 < (Prod.map f g b).2

tactic: exact Or.imp (And.imp hf.imp hg.monotone.imp) (And.imp hf.monotone.imp hg.imp)
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictMono f
hg : StrictMono g
a b : α × β
⊢ a.1 < b.1 ∧ a.2 ≤ b.2 ∨ a.1 ≤ b.1 ∧ a.2 < b.2 →
    (Prod.map f g a).1 < (Prod.map f g b).1 ∧ (Prod.map f g a).2 ≤ (Prod.map f g b).2 ∨
      (Prod.map f g a).1 ≤ (Prod.map f g b).1 ∧ (Prod.map f g a).2 < (Prod.map f g b).2
state_after: no goals
Theorem: Set.surjOn_iff_exists_map_subtype
File: Mathlib/Data/Set/Function.lean

tactic: rw [hfg, hx, Subtype.coe_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
x✝ : ∃ t' g, t ⊆ t' ∧ Surjective g ∧ ∀ (x : ↑s), f ↑x = ↑(g x)
y : β
hy : y ∈ t
t' : Set β
g : ↑s → ↑t'
htt' : t ⊆ t'
hg : Surjective g
hfg : ∀ (x : ↑s), f ↑x = ↑(g x)
x : ↑s
hx : g x = ⟨y, ⋯⟩
⊢ f ↑x = y
state_after: no goals
Theorem: Fin.exists_succAbove_eq_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rintro ⟨y, rfl⟩
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
⊢ (∃ z, x.succAbove z = y) → y ≠ x
state_after: case intro
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x : Fin (n + 1)
y : Fin n
⊢ x.succAbove y ≠ x

tactic: exact succAbove_ne _ _
state_before: case intro
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x : Fin (n + 1)
y : Fin n
⊢ x.succAbove y ≠ x
state_after: no goals
Theorem: Order.Icc_pred_left
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Ici_inter_Iic, Ici_pred, insert_inter_of_mem (mem_Iic.2 h)]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h : pred a ≤ b
⊢ Icc (pred a) b = insert (pred a) (Icc a b)
state_after: no goals
Theorem: IsIntegralCurve.comp_add
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

tactic: rw [isIntegralCurve_iff_isIntegralCurveOn] at *
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurve γ v
dt : ℝ
⊢ IsIntegralCurve (γ ∘ fun x => x + dt) v
state_after: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurveOn γ v univ
dt : ℝ
⊢ IsIntegralCurveOn (γ ∘ fun x => x + dt) v univ

tactic: exact hγ.comp_add _
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurveOn γ v univ
dt : ℝ
⊢ IsIntegralCurveOn (γ ∘ fun x => x + dt) v univ
state_after: no goals