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

tactic: rw [RatFunc.liftOn]
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : ↥K[X]⁰
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ { toFractionRing := Localization.mk n d }.liftOn f H = f n ↑d
state_after: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : ↥K[X]⁰
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ Localization.liftOn { toFractionRing := Localization.mk n d }.toFractionRing (fun p q => f p ↑q) ⋯ = f n ↑d

tactic: exact Localization.liftOn_mk _ _ _ _
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : ↥K[X]⁰
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ Localization.liftOn { toFractionRing := Localization.mk n d }.toFractionRing (fun p q => f p ↑q) ⋯ = f n ↑d
state_after: no goals
Theorem: Fin.cycleRange_of_lt
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: rw [cycleRange_of_le h.le, if_neg h.ne]
state_before: n : ℕ
i j : Fin n.succ
h : j < i
⊢ i.cycleRange j = j + 1
state_after: no goals
Theorem: Orientation.norm_div_cos_oangle_sub_left_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ ‖x‖ / (o.oangle (x - y) x).cos = ‖x - y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ‖x‖ / ((-o).oangle x (x - y)).cos = ‖x - y‖

tactic: exact (-o).norm_div_cos_oangle_sub_right_of_oangle_eq_pi_div_two h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ‖x‖ / ((-o).oangle x (x - y)).cos = ‖x - y‖
state_after: no goals
Theorem: Set.toFinset_inj
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← s.coe_toFinset, h, t.coe_toFinset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
h : s.toFinset = t.toFinset
⊢ s = t
state_after: no goals

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
h : s = t
⊢ s.toFinset = t.toFinset
state_after: no goals
Theorem: Composition.single_blocksFun
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: simp [blocksFun, single, blocks, i.2]
state_before: n✝ : ℕ
c : Composition n✝
n : ℕ
h : 0 < n
i : Fin (single n h).length
⊢ (single n h).blocksFun i = n
state_after: no goals
Theorem: SimpleGraph.Walk.getVert_zero
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases w <;> rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
w : G.Walk u v
⊢ w.getVert 0 = u
state_after: no goals
Theorem: Polynomial.degree_hermite
File: Mathlib/RingTheory/Polynomial/Hermite/Basic.lean

tactic: rw [degree_eq_of_le_of_coeff_ne_zero]
state_before: n : ℕ
⊢ (hermite n).degree = ↑n
state_after: case pn
n : ℕ
⊢ (hermite n).degree ≤ ↑n

case p1
n : ℕ
⊢ (hermite n).coeff n ≠ 0

tactic: simp_rw [degree_le_iff_coeff_zero, Nat.cast_lt]
state_before: case pn
n : ℕ
⊢ (hermite n).degree ≤ ↑n
state_after: case pn
n : ℕ
⊢ ∀ (m : ℕ), n < m → (hermite n).coeff m = 0

tactic: rintro m hnm
state_before: case pn
n : ℕ
⊢ ∀ (m : ℕ), n < m → (hermite n).coeff m = 0
state_after: case pn
n m : ℕ
hnm : n < m
⊢ (hermite n).coeff m = 0

tactic: exact coeff_hermite_of_lt hnm
state_before: case pn
n m : ℕ
hnm : n < m
⊢ (hermite n).coeff m = 0
state_after: no goals

tactic: simp [coeff_hermite_self n]
state_before: case p1
n : ℕ
⊢ (hermite n).coeff n ≠ 0
state_after: no goals
Theorem: Nat.nth_strictMono
File: Mathlib/Data/Nat/Nth.lean

tactic: rw [nth_eq_orderIsoOfNat hf]
state_before: p : ℕ → Prop
hf : (setOf p).Infinite
⊢ StrictMono (nth p)
state_after: p : ℕ → Prop
hf : (setOf p).Infinite
⊢ StrictMono (Subtype.val ∘ ⇑(Subtype.orderIsoOfNat (setOf p)))

tactic: exact (Subtype.strictMono_coe _).comp (OrderIso.strictMono _)
state_before: p : ℕ → Prop
hf : (setOf p).Infinite
⊢ StrictMono (Subtype.val ∘ ⇑(Subtype.orderIsoOfNat (setOf p)))
state_after: no goals
Theorem: Multiset.gcd_dedup
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s : Multiset α
⊢ (dedup 0).gcd = gcd 0
state_after: no goals

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 : s.dedup.gcd = s.gcd
⊢ (a ::ₘ s).dedup.gcd = (a ::ₘ s).gcd
state_after: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : s.dedup.gcd = s.gcd
h : a ∈ s
⊢ s.gcd = GCDMonoid.gcd a s.gcd

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

tactic: rw [← cons_erase h, fold_cons_left, ← gcd_assoc, gcd_same]
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : s.dedup.gcd = s.gcd
h : a ∈ s
⊢ fold GCDMonoid.gcd 0 s = GCDMonoid.gcd a (fold GCDMonoid.gcd 0 s)
state_after: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : s.dedup.gcd = s.gcd
h : a ∈ s
⊢ GCDMonoid.gcd a (fold GCDMonoid.gcd 0 (s.erase a)) = GCDMonoid.gcd (normalize a) (fold GCDMonoid.gcd 0 (s.erase a))

tactic: apply (associated_normalize _).gcd_eq_left
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
IH : s.dedup.gcd = s.gcd
h : a ∈ s
⊢ GCDMonoid.gcd a (fold GCDMonoid.gcd 0 (s.erase a)) = GCDMonoid.gcd (normalize a) (fold GCDMonoid.gcd 0 (s.erase a))
state_after: no goals
Theorem: ENNReal.rpow_lt_rpow_of_exponent_lt
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using hx'
state_before: x : ℝ≥0∞
y z : ℝ
hx : 1 < x
hx' : x ≠ ⊤
hyz : y < z
⊢ x ^ y < x ^ z
state_after: case intro
y z : ℝ
hyz : y < z
x : ℝ≥0
hx : 1 < ↑x
⊢ ↑x ^ y < ↑x ^ z

tactic: rw [one_lt_coe_iff] at hx
state_before: case intro
y z : ℝ
hyz : y < z
x : ℝ≥0
hx : 1 < ↑x
⊢ ↑x ^ y < ↑x ^ z
state_after: case intro
y z : ℝ
hyz : y < z
x : ℝ≥0
hx : 1 < x
⊢ ↑x ^ y < ↑x ^ z

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt (lt_trans zero_lt_one hx)),
  NNReal.rpow_lt_rpow_of_exponent_lt hx hyz]
state_before: case intro
y z : ℝ
hyz : y < z
x : ℝ≥0
hx : 1 < x
⊢ ↑x ^ y < ↑x ^ z
state_after: no goals
Theorem: Mathlib.Tactic.Abel.zero_termg
File: Mathlib/Tactic/Abel.lean

tactic: simp [termg, zero_zsmul]
state_before: α : Type u_1
inst✝ : AddCommGroup α
x a : α
⊢ termg 0 x a = a
state_after: no goals
Theorem: Group.closure_subset
File: Mathlib/Deprecated/Subgroup.lean

tactic: induction ha <;> simp [h _, *, ht.one_mem, ht.mul_mem, IsSubgroup.inv_mem_iff]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
s✝ s t : Set G
ht : IsSubgroup t
h : s ⊆ t
a : G
ha : a ∈ closure s
⊢ a ∈ t
state_after: no goals
Theorem: CategoryTheory.NatIso.naturality_2'
File: Mathlib/CategoryTheory/NatIso.lean

tactic: rw [← Category.assoc, ← naturality, Category.assoc, IsIso.hom_inv_id, Category.comp_id]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y : C
α : F ⟶ G
f : X ⟶ Y
x✝ : IsIso (α.app Y)
⊢ α.app X ≫ G.map f ≫ inv (α.app Y) = F.map f
state_after: no goals
Theorem: Homeomorph.isLittleO_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : α ≃ₜ β
b : β
f : β → E
g : β → F
⊢ f =o[𝓝 b] g ↔ (f ∘ ⇑e) =o[𝓝 (e.symm b)] (g ∘ ⇑e)
state_after: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : α ≃ₜ β
b : β
f : β → E
g : β → F
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 b) f g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 (e.symm b)) (f ∘ ⇑e) (g ∘ ⇑e)

tactic: exact forall₂_congr fun c _hc => e.isBigOWith_congr
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : α ≃ₜ β
b : β
f : β → E
g : β → F
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 b) f g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 (e.symm b)) (f ∘ ⇑e) (g ∘ ⇑e)
state_after: no goals
Theorem: AlgebraicGeometry.StructureSheaf.stalkSpecializes_stalk_to_fiber
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: change _ ≫ (StructureSheaf.stalkIso R x).hom = (StructureSheaf.stalkIso R y).hom ≫ _
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (structureSheaf R).presheaf.stalkSpecializes h ≫ stalkToFiberRingHom R x =
    stalkToFiberRingHom R y ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this
state_after: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (structureSheaf R).presheaf.stalkSpecializes h ≫ (stalkIso R x).hom =
    (stalkIso R y).hom ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this

tactic: rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (structureSheaf R).presheaf.stalkSpecializes h ≫ (stalkIso R x).hom =
    (stalkIso R y).hom ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this
state_after: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (stalkIso R y).inv ≫ (structureSheaf R).presheaf.stalkSpecializes h =
    (let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this) ≫
      (stalkIso R x).inv

tactic: exact localizationToStalk_stalkSpecializes h
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (stalkIso R y).inv ≫ (structureSheaf R).presheaf.stalkSpecializes h =
    (let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this) ≫
      (stalkIso R x).inv
state_after: no goals
Theorem: Complex.tendsto_exp_nhds_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp_rw [← comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_nhds_zero, tendsto_comap_iff]
state_before: α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (fun x => cexp (f x)) l (𝓝 0) ↔ Tendsto (fun x => (f x).re) l atBot
state_after: α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (re ∘ f) l atBot ↔ Tendsto (fun x => (f x).re) l atBot

tactic: rfl
state_before: α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (re ∘ f) l atBot ↔ Tendsto (fun x => (f x).re) l atBot
state_after: no goals
Theorem: Equiv.swap_mem_stabilizer
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: rw [MulAction.mem_stabilizer_iff, Set.ext_iff, ← swap_inv]
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ swap a b ∈ MulAction.stabilizer (Perm α) S ↔ (a ∈ S ↔ b ∈ S)
state_after: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), x ∈ (swap a b)⁻¹ • S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)

tactic: simp_rw [Set.mem_inv_smul_set_iff, Perm.smul_def, swap_apply_def]
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), x ∈ (swap a b)⁻¹ • S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)
state_after: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), (if x = a then b else if x = b then a else x) ∈ S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)

tactic: exact ⟨fun h ↦ by simpa [Iff.comm] using h a, by intros; split_ifs <;> simp [*]⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), (if x = a then b else if x = b then a else x) ∈ S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)
state_after: no goals

tactic: simpa [Iff.comm] using h a
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
h : ∀ (x : α), (if x = a then b else if x = b then a else x) ∈ S ↔ x ∈ S
⊢ a ∈ S ↔ b ∈ S
state_after: no goals

tactic: intros
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (a ∈ S ↔ b ∈ S) → ∀ (x : α), (if x = a then b else if x = b then a else x) ∈ S ↔ x ∈ S
state_after: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
a✝ : a ∈ S ↔ b ∈ S
x✝ : α
⊢ (if x✝ = a then b else if x✝ = b then a else x✝) ∈ S ↔ x✝ ∈ S

tactic: split_ifs <;> simp [*]
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
a✝ : a ∈ S ↔ b ∈ S
x✝ : α
⊢ (if x✝ = a then b else if x✝ = b then a else x✝) ∈ S ↔ x✝ ∈ S
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [pullbackZeroZeroIso]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (pullbackZeroZeroIso X Y).inv ≫ pullback.fst = prod.fst
state_after: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (limit.isoLimitCone
          { cone := PullbackCone.mk prod.fst prod.snd ⋯,
            isLimit :=
              isPullbackOfIsTerminalIsProduct 0 0 prod.fst prod.snd HasZeroObject.zeroIsTerminal
                (prodIsProd X Y) }).inv ≫
      pullback.fst =
    prod.fst

tactic: simp
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (limit.isoLimitCone
          { cone := PullbackCone.mk prod.fst prod.snd ⋯,
            isLimit :=
              isPullbackOfIsTerminalIsProduct 0 0 prod.fst prod.snd HasZeroObject.zeroIsTerminal
                (prodIsProd X Y) }).inv ≫
      pullback.fst =
    prod.fst
state_after: no goals
Theorem: Asymptotics.isLittleO_one_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [isLittleO_iff, norm_one, mul_one, Metric.nhds_basis_closedBall.tendsto_right_iff,
  Metric.mem_closedBall, dist_zero_right]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁵ : Norm E
inst✝¹⁴ : Norm F
inst✝¹³ : Norm G
inst✝¹² : SeminormedAddCommGroup E'
inst✝¹¹ : SeminormedAddCommGroup F'
inst✝¹⁰ : SeminormedAddCommGroup G'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F''
inst✝⁷ : NormedAddCommGroup G''
inst✝⁶ : SeminormedRing R
inst✝⁵ : SeminormedAddGroup E'''
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedDivisionRing 𝕜
inst✝² : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : One F
inst✝ : NormOneClass F
⊢ (f' =o[l] fun _x => 1) ↔ Tendsto f' l (𝓝 0)
state_after: no goals
Theorem: Wbtw.trans_right_left
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [wbtw_comm] at *
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
w x y z : P
h₁ : Wbtw R w x z
h₂ : Wbtw R x y z
⊢ Wbtw R w x y
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
w x y z : P
h₁ : Wbtw R z x w
h₂ : Wbtw R z y x
⊢ Wbtw R y x w

tactic: exact h₁.trans_left_right h₂
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
w x y z : P
h₁ : Wbtw R z x w
h₂ : Wbtw R z y x
⊢ Wbtw R y x w
state_after: no goals
Theorem: intervalIntegral.integral_const
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [integral_const', Real.volume_Ioc, ENNReal.toReal_ofReal', ← neg_sub b,
  max_zero_sub_eq_self]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
c : E
⊢ ∫ (x : ℝ) in a..b, c = (b - a) • c
state_after: no goals
Theorem: List.rotate_one_eq_self_iff_eq_replicate
File: Mathlib/Data/List/Rotate.lean

tactic: rwa [Nat.succ_eq_add_one, ← l.rotate_rotate, hn]
state_before: α : Type u
inst✝ : Nonempty α
l : List α
h : l.rotate 1 = l
n✝ n : ℕ
hn : l.rotate n = l
⊢ l.rotate n.succ = l
state_after: no goals
Theorem: IsSelfAdjoint.skewAdjointPart_apply
File: Mathlib/Algebra/Star/Module.lean

tactic: rw [skewAdjointPart_apply_coe, hx.star_eq, sub_self, smul_zero, ZeroMemClass.coe_zero]
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x : A
hx : IsSelfAdjoint x
⊢ ↑((skewAdjointPart R) x) = ↑0
state_after: no goals
Theorem: hasStrictDerivAt_pow
File: Mathlib/Analysis/Calculus/Deriv/Pow.lean

tactic: simp [hasStrictDerivAt_const]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
x : 𝕜
⊢ HasStrictDerivAt (fun x => x ^ 0) (↑0 * x ^ (0 - 1)) x
state_after: no goals

tactic: simpa using hasStrictDerivAt_id x
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
x : 𝕜
⊢ HasStrictDerivAt (fun x => x ^ 1) (↑1 * x ^ (1 - 1)) x
state_after: no goals

tactic: simpa [pow_succ, add_mul, mul_assoc] using
  (hasStrictDerivAt_pow (n + 1) x).mul (hasStrictDerivAt_id x)
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n✝ n : ℕ
x : 𝕜
⊢ HasStrictDerivAt (fun x => x ^ (n + 1 + 1)) (↑(n + 1 + 1) * x ^ (n + 1 + 1 - 1)) x
state_after: no goals
Theorem: range_deriv_subset_closure_span_image
File: Mathlib/Analysis/Calculus/Deriv/Slope.lean

tactic: rw [← derivWithin_univ]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
t : Set 𝕜
h : Dense t
⊢ range (deriv f) ⊆ closure ↑(Submodule.span 𝕜 (f '' t))
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
t : Set 𝕜
h : Dense t
⊢ range (derivWithin f univ) ⊆ closure ↑(Submodule.span 𝕜 (f '' t))

tactic: apply range_derivWithin_subset_closure_span_image
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
t : Set 𝕜
h : Dense t
⊢ range (derivWithin f univ) ⊆ closure ↑(Submodule.span 𝕜 (f '' t))
state_after: case h
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
t : Set 𝕜
h : Dense t
⊢ univ ⊆ closure (univ ∩ t)

tactic: simp [dense_iff_closure_eq.1 h]
state_before: case h
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
t : Set 𝕜
h : Dense t
⊢ univ ⊆ closure (univ ∩ t)
state_after: no goals
Theorem: ClosedEmbedding.closed_iff_image_closed
File: Mathlib/Topology/Maps.lean

tactic: rw [← preimage_image_eq s hf.inj]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : ClosedEmbedding f
s : Set X
h : IsClosed (f '' s)
⊢ IsClosed s
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : ClosedEmbedding f
s : Set X
h : IsClosed (f '' s)
⊢ IsClosed (f ⁻¹' (f '' s))

tactic: exact h.preimage hf.continuous
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : ClosedEmbedding f
s : Set X
h : IsClosed (f '' s)
⊢ IsClosed (f ⁻¹' (f '' s))
state_after: no goals
Theorem: Nat.eleven_dvd_iff
File: Mathlib/Data/Nat/Digits.lean

tactic: have t := dvd_iff_dvd_ofDigits 11 10 (-1 : ℤ) (by norm_num) n
state_before: n : ℕ
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
state_after: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ ofDigits (-1) (digits 10 n)
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum

tactic: rw [ofDigits_neg_one] at t
state_before: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ ofDigits (-1) (digits 10 n)
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
state_after: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum

tactic: exact t
state_before: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
state_after: no goals

tactic: norm_num
state_before: n : ℕ
⊢ ↑11 ∣ ↑10 - -1
state_after: no goals
Theorem: Order.Ico_pred_left
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Ici_inter_Iio, Ici_pred, insert_inter_of_mem (mem_Iio.2 h)]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h : pred a < b
⊢ Ico (pred a) b = insert (pred a) (Ico a b)
state_after: no goals