ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.rotate_eq_rotate'
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
n : ℕ
h : l.length = 0
⊢ l.rotate n = l.rotate' n
state_after: no goals
tactic: simp_all [length_eq_zero]
state_before: α : Type u
l : List α
n : ℕ
h : ¬l.length = 0
⊢ l.rotate n = l.rotate' n
state_after: α : Type u
l : List α
n : ℕ
h : ¬l.length = 0
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l
tactic: rw [← rotate'_mod,
        rotate'_eq_drop_append_take (le_of_lt (Nat.mod_lt _ (Nat.pos_of_ne_zero h)))]
state_before: α : Type u
l : List α
n : ℕ
h : ¬l.length = 0
⊢ l.rotate n = drop (n % l.length) l ++ take (n % l.length) l
state_after: no goals
tactic: simp [rotate]
Theorem: SetTheory.PGame.add_moveLeft_inl
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
i : x.LeftMoves
⊢ (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y
state_after: case mk
xl xr : Type u
y : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = (mk α✝ β✝ a✝¹ a✝).moveLeft i + y
tactic: cases x
state_before: case mk
xl xr : Type u
y : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = (mk α✝ β✝ a✝¹ a✝).moveLeft i + y
state_after: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveLeft (toLeftMovesAdd (Sum.inl i)) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i + mk α✝ β✝ a✝¹ a✝
tactic: cases y
state_before: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveLeft (toLeftMovesAdd (Sum.inl i)) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i + mk α✝ β✝ a✝¹ a✝
state_after: no goals
tactic: rfl
Theorem: FirstOrder.Language.exists_elementarilyEquivalent_card_eq
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
M : Type w'
inst✝¹ : L.Structure M
inst✝ : Infinite M
κ : Cardinal.{w}
h1 : ℵ₀ ≤ κ
h2 : lift.{w, max u v} L.card ≤ lift.{max u v, w} κ
⊢ ∃ N, (M ≅[L] ↑N) ∧ #↑N = κ
state_after: case intro.intro.inl
L : Language
T : L.Theory
α : Type w
n : ℕ
M : Type w'
inst✝¹ : L.Structure M
inst✝ : Infinite M
κ : Cardinal.{w}
h1 : ℵ₀ ≤ κ
h2 : lift.{w, max u v} L.card ≤ lift.{max u v, w} κ
N : Bundled L.Structure
hNκ : #↑N = κ
NM : Nonempty (↑N ↪ₑ[L] M)
⊢ ∃ N, (M ≅[L] ↑N) ∧ #↑N = κ

case intro.intro.inr
L : Language
T : L.Theory
α : Type w
n : ℕ
M : Type w'
inst✝¹ : L.Structure M
inst✝ : Infinite M
κ : Cardinal.{w}
h1 : ℵ₀ ≤ κ
h2 : lift.{w, max u v} L.card ≤ lift.{max u v, w} κ
N : Bundled L.Structure
hNκ : #↑N = κ
MN : Nonempty (M ↪ₑ[L] ↑N)
⊢ ∃ N, (M ≅[L] ↑N) ∧ #↑N = κ
tactic: obtain ⟨N, NM | MN, hNκ⟩ := exists_elementaryEmbedding_card_eq L M κ h1 h2
Theorem: MeasureTheory.all_ae_of
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
ι : Sort u_4
p : α → ι → Prop
hp : ∀ᵐ (a : α) ∂μ, ∀ (i : ι), p a i
i : ι
⊢ ∀ᵐ (a : α) ∂μ, p a i
state_after: no goals
tactic: filter_upwards [hp] with a ha using ha i
Theorem: pi_norm_const
File: Mathlib/Analysis/Normed/Group/Constructions.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
F : Type u_3
π : ι → Type u_4
inst✝³ : Fintype ι
inst✝² : (i : ι) → SeminormedGroup (π i)
inst✝¹ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
inst✝ : Nonempty ι
a : E
⊢ ‖fun _i => a‖ = ‖a‖
state_after: no goals
tactic: simpa only [← dist_one_right] using dist_pi_const a 1
Theorem: Convex.image_sub_le_mul_sub_of_deriv_le
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
C : ℝ
le_hf' : ∀ x ∈ interior D, deriv f x ≤ C
x✝ : ℝ
hx✝ : x✝ ∈ D
y : ℝ
hy : y ∈ D
hxy : x✝ ≤ y
x : ℝ
hx : x ∈ interior D
⊢ -C ≤ deriv (fun y => -f y) x
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
C : ℝ
le_hf' : ∀ x ∈ interior D, deriv f x ≤ C
x✝ : ℝ
hx✝ : x✝ ∈ D
y : ℝ
hy : y ∈ D
hxy : x✝ ≤ y
x : ℝ
hx : x ∈ interior D
⊢ deriv f x ≤ C
tactic: rw [deriv.neg, neg_le_neg_iff]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
C : ℝ
le_hf' : ∀ x ∈ interior D, deriv f x ≤ C
x✝ : ℝ
hx✝ : x✝ ∈ D
y : ℝ
hy : y ∈ D
hxy : x✝ ≤ y
x : ℝ
hx : x ∈ interior D
⊢ deriv f x ≤ C
state_after: no goals
tactic: exact le_hf' x hx
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
C : ℝ
le_hf' : ∀ x ∈ interior D, deriv f x ≤ C
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
hxy : x ≤ y
hf'_ge : ∀ x ∈ interior D, -C ≤ deriv (fun y => -f y) x
⊢ f y - f x ≤ C * (y - x)
state_after: no goals
tactic: linarith [hD.mul_sub_le_image_sub_of_le_deriv hf.neg hf'.neg hf'_ge x hx y hy hxy]
Theorem: IsometryEquiv.funUnique_toFun
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁴ : PseudoEMetricSpace α
inst✝³ : PseudoEMetricSpace β
inst✝² : PseudoEMetricSpace γ
inst✝¹ : Unique ι
inst✝ : Fintype ι
x hx : ι → α
⊢ edist ((Equiv.funUnique ι α).toFun x) ((Equiv.funUnique ι α).toFun hx) = edist x hx
state_after: no goals
tactic: simp [edist_pi_def, Finset.univ_unique, Finset.sup_singleton]
Theorem: tendsto_one_plus_div_rpow_exp
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: t : ℝ
⊢ Tendsto (fun x => (1 + t / x) ^ x) atTop (𝓝 (rexp t))
state_after: t : ℝ
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x
tactic: apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
state_before: t : ℝ
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x
state_after: t : ℝ
h₁ : 1 / 2 < 1
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x
tactic: have h₁ : (1 : ℝ) / 2 < 1 := by linarith
state_before: t : ℝ
h₁ : 1 / 2 < 1
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x
state_after: t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x
tactic: have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
state_before: t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x
state_after: t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
⊢ (rexp ∘ fun x => x * log (1 + t / x)) x = (fun x => (1 + t / x) ^ x) x
tactic: refine (eventually_ge_of_tendsto_gt h₁ h₂).mono fun x hx => ?_
state_before: t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
⊢ (rexp ∘ fun x => x * log (1 + t / x)) x = (fun x => (1 + t / x) ^ x) x
state_after: t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
hx' : 0 < 1 + t / x
⊢ (rexp ∘ fun x => x * log (1 + t / x)) x = (fun x => (1 + t / x) ^ x) x
tactic: have hx' : 0 < 1 + t / x := by linarith
state_before: t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
hx' : 0 < 1 + t / x
⊢ (rexp ∘ fun x => x * log (1 + t / x)) x = (fun x => (1 + t / x) ^ x) x
state_after: no goals
tactic: simp [mul_comm x, exp_mul, exp_log hx']
Theorem: Nat.cast_eq_zero
File: Mathlib/Algebra/CharZero/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : AddMonoidWithOne R
inst✝ : CharZero R
n : ℕ
⊢ ↑n = 0 ↔ n = 0
state_after: no goals
tactic: rw [← cast_zero, cast_inj]
Theorem: PadicInt.ker_toZModPow
File: Mathlib/NumberTheory/Padics/RingHoms.lean

Proof steps:
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
n : ℕ
⊢ RingHom.ker (toZModPow n) = Ideal.span {↑p ^ n}
state_after: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ x ∈ RingHom.ker (toZModPow n) ↔ x ∈ Ideal.span {↑p ^ n}
tactic: ext x
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ x ∈ RingHom.ker (toZModPow n) ↔ x ∈ Ideal.span {↑p ^ n}
state_after: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ (toZModPow n) x = 0 ↔ x ∈ Ideal.span {↑p ^ n}
tactic: rw [RingHom.mem_ker]
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ (toZModPow n) x = 0 ↔ x ∈ Ideal.span {↑p ^ n}
state_after: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ (toZModPow n) x = 0 → x ∈ Ideal.span {↑p ^ n}

case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ x ∈ Ideal.span {↑p ^ n} → (toZModPow n) x = 0
tactic: constructor
Theorem: Equiv.Perm.Disjoint.mono
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g x y : Perm α
h : f.Disjoint g
hf : x.support ≤ f.support
hg : y.support ≤ g.support
⊢ x.Disjoint y
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g x y : Perm α
h : _root_.Disjoint f.support g.support
hf : x.support ≤ f.support
hg : y.support ≤ g.support
⊢ _root_.Disjoint x.support y.support
tactic: rw [disjoint_iff_disjoint_support] at h ⊢
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g x y : Perm α
h : _root_.Disjoint f.support g.support
hf : x.support ≤ f.support
hg : y.support ≤ g.support
⊢ _root_.Disjoint x.support y.support
state_after: no goals
tactic: exact h.mono hf hg
Theorem: WeierstrassCurve.map_preΨ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (W.map f).preΨ n = Polynomial.map f (W.preΨ n)
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ preNormEDS ((mapRingHom f) W.Ψ₂Sq ^ 2) ((mapRingHom f) W.Ψ₃) ((mapRingHom f) W.preΨ₄) n =
    preNormEDS ((mapRingHom f) (W.Ψ₂Sq ^ 2)) ((mapRingHom f) W.Ψ₃) ((mapRingHom f) W.preΨ₄) n
tactic: simp only [preΨ, map_Ψ₂Sq, map_Ψ₃, map_preΨ₄, ← coe_mapRingHom, map_preNormEDS]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ preNormEDS ((mapRingHom f) W.Ψ₂Sq ^ 2) ((mapRingHom f) W.Ψ₃) ((mapRingHom f) W.preΨ₄) n =
    preNormEDS ((mapRingHom f) (W.Ψ₂Sq ^ 2)) ((mapRingHom f) W.Ψ₃) ((mapRingHom f) W.preΨ₄) n
state_after: no goals
tactic: map_simp
Theorem: Quiver.Path.cast_nil
File: Mathlib/Combinatorics/Quiver/Cast.lean

Proof steps:
state_before: U : Type u_1
inst✝ : Quiver U
u u' : U
hu : u = u'
⊢ cast hu hu nil = nil
state_after: U : Type u_1
inst✝ : Quiver U
u' : U
⊢ cast ⋯ ⋯ nil = nil
tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u' : U
⊢ cast ⋯ ⋯ nil = nil
state_after: no goals
tactic: rfl
Theorem: Rat.mul_self_den
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: q : ℚ
⊢ (q * q).den = q.den * q.den
state_after: q : ℚ
⊢ (q.num.natAbs * q.num.natAbs).Coprime (q.den * q.den)
tactic: rw [Rat.mul_den, Int.natAbs_mul, Nat.Coprime.gcd_eq_one, Nat.div_one]
state_before: q : ℚ
⊢ (q.num.natAbs * q.num.natAbs).Coprime (q.den * q.den)
state_after: no goals
tactic: exact (q.reduced.mul_right q.reduced).mul (q.reduced.mul_right q.reduced)
Theorem: CategoryTheory.FunctorToTypes.eqToHom_map_comp_apply
File: Mathlib/CategoryTheory/Types.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G H : C ⥤ Type w
X Y Z : C
σ : F ⟶ G
τ : G ⟶ H
p : X = Y
q : Y = Z
x : F.obj X
⊢ F.map (eqToHom q) (F.map (eqToHom p) x) = F.map (eqToHom ⋯) x
state_after: no goals
tactic: aesop_cat
Theorem: Action.associator_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X Y Z : Action V G
⊢ (α_ X Y Z).inv.hom = (α_ X.V Y.V Z.V).inv
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X Y Z : Action V G
⊢ ((𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) ≫ (α_ X.V Y.V Z.V).inv) ≫ (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) = (α_ X.V Y.V Z.V).inv
tactic: dsimp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X Y Z : Action V G
⊢ ((𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) ≫ (α_ X.V Y.V Z.V).inv) ≫ (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) = (α_ X.V Y.V Z.V).inv
state_after: no goals
tactic: simp
Theorem: HasFTaylorSeriesUpTo.zero_eq'
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (f x)
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (p x 0).uncurry0
tactic: rw [← h.zero_eq x]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (p x 0).uncurry0
state_after: no goals
tactic: exact (p x 0).uncurry0_curry0.symm
Theorem: Int.strictAntiOn_natAbs
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: a✝ b✝ : ℤ
n : ℕ
a : ℤ
x✝ : a ∈ Iic 0
b : ℤ
hb : b ∈ Iic 0
hab : a < b
⊢ b.natAbs < a.natAbs
state_after: no goals
tactic: simpa [Int.natAbs_neg] using
    natAbs_lt_natAbs_of_nonneg_of_lt (Right.nonneg_neg_iff.mpr hb) (neg_lt_neg_iff.mpr hab)
Theorem: WeierstrassCurve.Jacobian.equiv_some_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ P x * ![P x / P z ^ 2, P y / P z ^ 3, 1] z ^ 2 = ![P x / P z ^ 2, P y / P z ^ 3, 1] x * P z ^ 2
state_after: no goals
tactic: linear_combination (norm := (matrix_simp; ring1)) -P x * div_self (pow_ne_zero 2 hPz)
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ P y * ![P x / P z ^ 2, P y / P z ^ 3, 1] z ^ 3 = ![P x / P z ^ 2, P y / P z ^ 3, 1] y * P z ^ 3
state_after: no goals
tactic: linear_combination (norm := (matrix_simp; ring1)) -P y * div_self (pow_ne_zero 3 hPz)
Theorem: Fin.predAbove_right_last
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i.predAbove (last (n + 1)) = last n
state_after: no goals
tactic: rw [predAbove_of_castSucc_lt _ _ (castSucc_lt_last _), pred_last]
Theorem: Algebra.Generators.baseChange_val
File: Mathlib/RingTheory/Generators.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
⊢ Generators T (T ⊗[R] S)
state_after: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
⊢ Function.Surjective ⇑(aeval fun x => 1 ⊗ₜ[R] P.val x)
tactic: apply Generators.ofSurjective (fun x ↦ 1 ⊗ₜ[R] P.val x)
state_before: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
⊢ Function.Surjective ⇑(aeval fun x => 1 ⊗ₜ[R] P.val x)
state_after: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
x : T ⊗[R] S
⊢ ∃ a, (aeval fun x => 1 ⊗ₜ[R] P.val x) a = x
tactic: intro x
state_before: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
x : T ⊗[R] S
⊢ ∃ a, (aeval fun x => 1 ⊗ₜ[R] P.val x) a = x
state_after: no goals
tactic: induction x using TensorProduct.induction_on with
  | zero => exact ⟨0, map_zero _⟩
  | tmul a b =>
    let X := P.σ b
    use a • MvPolynomial.map (algebraMap R T) X
    simp only [LinearMapClass.map_smul, X, aeval_map_algebraMap]
    have : ∀ y : P.Ring,
      aeval (fun x ↦ (1 ⊗ₜ[R] P.val x : T ⊗[R] S)) y = 1 ⊗ₜ aeval (fun x ↦ P.val x) y := by
      intro y
      induction y using MvPolynomial.induction_on with
      | h_C a =>
        rw [aeval_C, aeval_C, TensorProduct.algebraMap_apply, algebraMap_eq_smul_one, smul_tmul,
          algebraMap_eq_smul_one]
      | h_add p q hp hq => simp [map_add, tmul_add, hp, hq]
      | h_X p i hp => simp [hp]
    rw [this, P.aeval_val_σ, smul_tmul', smul_eq_mul, mul_one]
  | add x y ex ey =>
    obtain ⟨a, ha⟩ := ex
    obtain ⟨b, hb⟩ := ey
    use (a + b)
    rw [map_add, ha, hb]
Theorem: Finset.le_sum_of_subadditive
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ (Multiset.map f (Multiset.map (fun i => g i) s.val)).prod ≤ ∏ i ∈ s, f (g i)
tactic: refine le_trans (Multiset.le_prod_of_submultiplicative f h_one h_mul _) ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ (Multiset.map f (Multiset.map (fun i => g i) s.val)).prod ≤ ∏ i ∈ s, f (g i)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ (Multiset.map (f ∘ fun i => g i) s.val).prod ≤ ∏ i ∈ s, f (g i)
tactic: rw [Multiset.map_map]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ (Multiset.map (f ∘ fun i => g i) s.val).prod ≤ ∏ i ∈ s, f (g i)
state_after: no goals
tactic: rfl
Theorem: add_abs_nonneg
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ 1 ≤ a * mabs a
state_after: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ a * a⁻¹ ≤ a * mabs a
tactic: rw [← mul_right_inv a]
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ a * a⁻¹ ≤ a * mabs a
state_after: no goals
tactic: exact mul_le_mul_left' (inv_le_mabs a) _
Theorem: ValuationSubring.principalUnitGroup_injective
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A.principalUnitGroup = B.principalUnitGroup
⊢ A = B
state_after: no goals
tactic: simpa [le_antisymm_iff, principalUnitGroup_le_principalUnitGroup] using h.symm
Theorem: Orientation.tan_oangle_add_left_mul_norm_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
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)
⊢ (o.oangle (x + y) y).tan * ‖y‖ = ‖x‖
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)
⊢ ((-o).oangle y (x + y)).tan * ‖y‖ = ‖x‖
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 y x = ↑(π / 2)
⊢ ((-o).oangle y (x + y)).tan * ‖y‖ = ‖x‖
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)
⊢ ((-o).oangle y (y + x)).tan * ‖y‖ = ‖x‖
tactic: rw [add_comm]
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)
⊢ ((-o).oangle y (y + x)).tan * ‖y‖ = ‖x‖
state_after: no goals
tactic: exact (-o).tan_oangle_add_right_mul_norm_of_oangle_eq_pi_div_two h