1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: WittVector.iterate_verschiebung_coeff
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: induction' n with k ih
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
n k : ℕ
⊢ ((⇑verschiebung)^[n] x).coeff (k + n) = x.coeff k
state_after: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
⊢ ((⇑verschiebung)^[0] x).coeff (k + 0) = x.coeff k

case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k✝ k : ℕ
ih : ((⇑verschiebung)^[k] x).coeff (k✝ + k) = x.coeff k✝
⊢ ((⇑verschiebung)^[k + 1] x).coeff (k✝ + (k + 1)) = x.coeff k✝

tactic: simp
state_before: case zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
⊢ ((⇑verschiebung)^[0] x).coeff (k + 0) = x.coeff k
state_after: no goals

tactic: rw [iterate_succ_apply', Nat.add_succ, verschiebung_coeff_succ]
state_before: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k✝ k : ℕ
ih : ((⇑verschiebung)^[k] x).coeff (k✝ + k) = x.coeff k✝
⊢ ((⇑verschiebung)^[k + 1] x).coeff (k✝ + (k + 1)) = x.coeff k✝
state_after: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k✝ k : ℕ
ih : ((⇑verschiebung)^[k] x).coeff (k✝ + k) = x.coeff k✝
⊢ ((⇑verschiebung)^[k] x).coeff (k✝ + k) = x.coeff k✝

tactic: exact ih
state_before: case succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k✝ k : ℕ
ih : ((⇑verschiebung)^[k] x).coeff (k✝ + k) = x.coeff k✝
⊢ ((⇑verschiebung)^[k] x).coeff (k✝ + k) = x.coeff k✝
state_after: no goals
Theorem: AntivaryOn.card_smul_sum_le_sum_smul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: exact hfg.dual_right.sum_smul_sum_le_card_smul_sum
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : AntivaryOn f g ↑s
⊢ s.card • ∑ i ∈ s, f i • g i ≤ (∑ i ∈ s, f i) • ∑ i ∈ s, g i
state_after: no goals
Theorem: infClosure_singleton
File: Mathlib/Order/SupClosed.lean

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s t : Set α
a b : α
⊢ infClosure {a} = {a}
state_after: no goals
Theorem: Complex.tanh_mul_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [tanh_eq_sinh_div_cosh, cosh_mul_I, sinh_mul_I, mul_div_right_comm, tan]
state_before: x y : ℂ
⊢ tanh (x * I) = tan x * I
state_after: no goals
Theorem: WithBot.preimage_coe_Ioi_bot
File: Mathlib/Order/Interval/Set/WithBotTop.lean

tactic: rw [← range_coe, preimage_range]
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some ⁻¹' Ioi ⊥ = univ
state_after: no goals
Theorem: Module.subsingleton_dual_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: refine ⟨fun h ↦ ⟨fun v w ↦ ?_⟩, fun h ↦ ⟨fun f g ↦ ?_⟩⟩
state_before: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ Subsingleton (Dual K V) ↔ Subsingleton V
state_after: case refine_1
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton (Dual K V)
v w : V
⊢ v = w

case refine_2
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton V
f g : Dual K V
⊢ f = g

tactic: rw [← sub_eq_zero, ← forall_dual_apply_eq_zero_iff K (v - w)]
state_before: case refine_1
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton (Dual K V)
v w : V
⊢ v = w
state_after: case refine_1
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton (Dual K V)
v w : V
⊢ ∀ (φ : Dual K V), φ (v - w) = 0

tactic: intros f
state_before: case refine_1
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton (Dual K V)
v w : V
⊢ ∀ (φ : Dual K V), φ (v - w) = 0
state_after: case refine_1
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton (Dual K V)
v w : V
f : Dual K V
⊢ f (v - w) = 0

tactic: simp [Subsingleton.elim f 0]
state_before: case refine_1
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton (Dual K V)
v w : V
f : Dual K V
⊢ f (v - w) = 0
state_after: no goals

tactic: ext v
state_before: case refine_2
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton V
f g : Dual K V
⊢ f = g
state_after: case refine_2.h
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton V
f g : Dual K V
v : V
⊢ f v = g v

tactic: simp [Subsingleton.elim v 0]
state_before: case refine_2.h
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : Subsingleton V
f g : Dual K V
v : V
⊢ f v = g v
state_after: no goals
Theorem: ZMod.isSquare_neg_one_mul
File: Mathlib/NumberTheory/SumTwoSquares.lean

tactic: have : IsSquare (-1 : ZMod m × ZMod n) := by
  rw [show (-1 : ZMod m × ZMod n) = ((-1 : ZMod m), (-1 : ZMod n)) from rfl]
  obtain ⟨x, hx⟩ := hm
  obtain ⟨y, hy⟩ := hn
  rw [hx, hy]
  exact ⟨(x, y), rfl⟩
state_before: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
⊢ IsSquare (-1)
state_after: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
this : IsSquare (-1)
⊢ IsSquare (-1)

tactic: simpa only [RingEquiv.map_neg_one] using this.map (ZMod.chineseRemainder hc).symm
state_before: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
this : IsSquare (-1)
⊢ IsSquare (-1)
state_after: no goals

tactic: rw [show (-1 : ZMod m × ZMod n) = ((-1 : ZMod m), (-1 : ZMod n)) from rfl]
state_before: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
⊢ IsSquare (-1)
state_after: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
⊢ IsSquare (-1, -1)

tactic: obtain ⟨x, hx⟩ := hm
state_before: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
⊢ IsSquare (-1, -1)
state_after: case intro
m n : ℕ
hc : m.Coprime n
hn : IsSquare (-1)
x : ZMod m
hx : -1 = x * x
⊢ IsSquare (-1, -1)

tactic: obtain ⟨y, hy⟩ := hn
state_before: case intro
m n : ℕ
hc : m.Coprime n
hn : IsSquare (-1)
x : ZMod m
hx : -1 = x * x
⊢ IsSquare (-1, -1)
state_after: case intro.intro
m n : ℕ
hc : m.Coprime n
x : ZMod m
hx : -1 = x * x
y : ZMod n
hy : -1 = y * y
⊢ IsSquare (-1, -1)

tactic: rw [hx, hy]
state_before: case intro.intro
m n : ℕ
hc : m.Coprime n
x : ZMod m
hx : -1 = x * x
y : ZMod n
hy : -1 = y * y
⊢ IsSquare (-1, -1)
state_after: case intro.intro
m n : ℕ
hc : m.Coprime n
x : ZMod m
hx : -1 = x * x
y : ZMod n
hy : -1 = y * y
⊢ IsSquare (x * x, y * y)

tactic: exact ⟨(x, y), rfl⟩
state_before: case intro.intro
m n : ℕ
hc : m.Coprime n
x : ZMod m
hx : -1 = x * x
y : ZMod n
hy : -1 = y * y
⊢ IsSquare (x * x, y * y)
state_after: no goals
Theorem: mul_add_mul_lt_mul_add_mul
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: obtain ⟨b, rfl⟩ := exists_add_of_le hab.le
state_before: α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a b c d : α
inst✝ : ExistsAddOfLE α
hab : a < b
hcd : c < d
⊢ a * d + b * c < a * c + b * d
state_after: case intro
α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a c d : α
inst✝ : ExistsAddOfLE α
hcd : c < d
b : α
hab : a < a + b
⊢ a * d + (a + b) * c < a * c + (a + b) * d

tactic: obtain ⟨d, rfl⟩ := exists_add_of_le hcd.le
state_before: case intro
α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a c d : α
inst✝ : ExistsAddOfLE α
hcd : c < d
b : α
hab : a < a + b
⊢ a * d + (a + b) * c < a * c + (a + b) * d
state_after: case intro.intro
α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a c : α
inst✝ : ExistsAddOfLE α
b : α
hab : a < a + b
d : α
hcd : c < c + d
⊢ a * (c + d) + (a + b) * c < a * c + (a + b) * (c + d)

tactic: rw [mul_add, add_right_comm, mul_add, ← add_assoc]
state_before: case intro.intro
α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a c : α
inst✝ : ExistsAddOfLE α
b : α
hab : a < a + b
d : α
hcd : c < c + d
⊢ a * (c + d) + (a + b) * c < a * c + (a + b) * (c + d)
state_after: case intro.intro
α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a c : α
inst✝ : ExistsAddOfLE α
b : α
hab : a < a + b
d : α
hcd : c < c + d
⊢ a * c + (a + b) * c + a * d < a * c + (a + b) * c + (a + b) * d

tactic: exact add_lt_add_left (mul_lt_mul_of_pos_right hab <| (lt_add_iff_pos_right _).1 hcd) _
state_before: case intro.intro
α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a c : α
inst✝ : ExistsAddOfLE α
b : α
hab : a < a + b
d : α
hcd : c < c + d
⊢ a * c + (a + b) * c + a * d < a * c + (a + b) * c + (a + b) * d
state_after: no goals
Theorem: Complex.ofReal_arctan
File: Mathlib/Analysis/SpecialFunctions/Complex/Arctan.lean

tactic: conv_rhs => rw [← Real.tan_arctan x]
state_before: x : ℝ
⊢ ↑(Real.arctan x) = (↑x).arctan
state_after: x : ℝ
⊢ ↑(Real.arctan x) = (↑(Real.tan (Real.arctan x))).arctan

tactic: rw [ofReal_tan, arctan_tan]
state_before: x : ℝ
⊢ ↑(Real.arctan x) = (↑(Real.tan (Real.arctan x))).arctan
state_after: case h₀
x : ℝ
⊢ ↑(Real.arctan x) ≠ ↑π / 2

case h₁
x : ℝ
⊢ -(π / 2) < (↑(Real.arctan x)).re

case h₂
x : ℝ
⊢ (↑(Real.arctan x)).re ≤ π / 2

tactic: all_goals norm_cast
state_before: case h₀
x : ℝ
⊢ ↑(Real.arctan x) ≠ ↑π / 2

case h₁
x : ℝ
⊢ -(π / 2) < (↑(Real.arctan x)).re

case h₂
x : ℝ
⊢ (↑(Real.arctan x)).re ≤ π / 2
state_after: case h₀
x : ℝ
⊢ ¬Real.arctan x = π / 2

case h₁
x : ℝ
⊢ -(π / 2) < Real.arctan x

case h₂
x : ℝ
⊢ Real.arctan x ≤ π / 2

tactic: norm_cast
state_before: case h₂
x : ℝ
⊢ (↑(Real.arctan x)).re ≤ π / 2
state_after: case h₂
x : ℝ
⊢ Real.arctan x ≤ π / 2

tactic: rw [← ne_eq]
state_before: case h₀
x : ℝ
⊢ ¬Real.arctan x = π / 2
state_after: case h₀
x : ℝ
⊢ Real.arctan x ≠ π / 2

tactic: exact (Real.arctan_lt_pi_div_two _).ne
state_before: case h₀
x : ℝ
⊢ Real.arctan x ≠ π / 2
state_after: no goals

tactic: exact Real.neg_pi_div_two_lt_arctan _
state_before: case h₁
x : ℝ
⊢ -(π / 2) < Real.arctan x
state_after: no goals

tactic: exact (Real.arctan_lt_pi_div_two _).le
state_before: case h₂
x : ℝ
⊢ Real.arctan x ≤ π / 2
state_after: no goals
Theorem: Rat.add_comm
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [add_def, Int.add_comm, Int.mul_comm, Nat.mul_comm]
state_before: q a b c : ℚ
⊢ a + b = b + a
state_after: no goals
Theorem: Set.subset_singleton_iff_eq
File: Mathlib/Data/Set/Basic.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
⊢ s ⊆ {x} ↔ s = ∅ ∨ s = {x}
state_after: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
⊢ ∅ ⊆ {x} ↔ ∅ = ∅ ∨ ∅ = {x}

case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
hs : s.Nonempty
⊢ s ⊆ {x} ↔ s = ∅ ∨ s = {x}

tactic: exact ⟨fun _ => Or.inl rfl, fun _ => empty_subset _⟩
state_before: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
⊢ ∅ ⊆ {x} ↔ ∅ = ∅ ∨ ∅ = {x}
state_after: no goals

tactic: simp [eq_singleton_iff_nonempty_unique_mem, hs, hs.ne_empty]
state_before: case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
hs : s.Nonempty
⊢ s ⊆ {x} ↔ s = ∅ ∨ s = {x}
state_after: no goals
Theorem: Polynomial.leadingCoeff_X_pow_sub_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C r, leadingCoeff_X_pow_add_C hn]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Ring R
n : ℕ
hn : 0 < n
r : R
⊢ (X ^ n - C r).leadingCoeff = 1
state_after: no goals
Theorem: Ordinal.nfp_mul_eq_opow_omega
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rcases eq_zero_or_pos a with ha | ha
state_before: a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
⊢ nfp (fun x => a * x) b = a ^ ω
state_after: case inl
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : a = 0
⊢ nfp (fun x => a * x) b = a ^ ω

case inr
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) b = a ^ ω

tactic: apply le_antisymm
state_before: case inr
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) b = a ^ ω
state_after: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) b ≤ a ^ ω

case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ a ^ ω ≤ nfp (fun x => a * x) b

tactic: rw [← nfp_mul_one ha]
state_before: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ a ^ ω ≤ nfp (fun x => a * x) b
state_after: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) 1 ≤ nfp (fun x => a * x) b

tactic: exact nfp_monotone (mul_isNormal ha).monotone (one_le_iff_pos.2 hb)
state_before: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) 1 ≤ nfp (fun x => a * x) b
state_after: no goals

tactic: rw [ha, zero_opow omega_ne_zero] at hba ⊢
state_before: case inl
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : a = 0
⊢ nfp (fun x => a * x) b = a ^ ω
state_after: case inl
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ 0
ha : a = 0
⊢ nfp (fun x => 0 * x) b = 0

tactic: rw [Ordinal.le_zero.1 hba, nfp_zero_mul]
state_before: case inl
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ 0
ha : a = 0
⊢ nfp (fun x => 0 * x) b = 0
state_after: case inl
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ 0
ha : a = 0
⊢ id 0 = 0

tactic: rfl
state_before: case inl
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ 0
ha : a = 0
⊢ id 0 = 0
state_after: no goals

tactic: apply nfp_le_fp (mul_isNormal ha).monotone hba
state_before: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) b ≤ a ^ ω
state_after: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ a * a ^ ω ≤ a ^ ω

tactic: rw [← opow_one_add, one_add_omega]
state_before: case inr.a
a b : Ordinal.{u}
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ a * a ^ ω ≤ a ^ ω
state_after: no goals
Theorem: eVariationOn.comp_ofDual
File: Mathlib/Analysis/BoundedVariation.lean

tactic: convert comp_eq_of_antitoneOn f ofDual fun _ _ _ _ => id
state_before: α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
β : Type u_3
inst✝ : LinearOrder β
f : α → E
s : Set α
⊢ eVariationOn (f ∘ ⇑ofDual) (⇑ofDual ⁻¹' s) = eVariationOn f s
state_after: case h.e'_3.h.e'_6
α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
β : Type u_3
inst✝ : LinearOrder β
f : α → E
s : Set α
⊢ s = ⇑ofDual '' (⇑ofDual ⁻¹' s)

tactic: simp only [Equiv.image_preimage]
state_before: case h.e'_3.h.e'_6
α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
β : Type u_3
inst✝ : LinearOrder β
f : α → E
s : Set α
⊢ s = ⇑ofDual '' (⇑ofDual ⁻¹' s)
state_after: no goals
Theorem: Finmap.keys_ext
File: Mathlib/Data/Finmap.lean

tactic: simp [keys, AList.keys]
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
⊢ ⟦s₁⟧.keys = ⟦s₂⟧.keys ↔ s₁.keys ~ s₂.keys
state_after: no goals
Theorem: Equiv.forall_congr
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp [h]
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (a : α), p a ↔ q (e a)
⊢ (∀ (b : β), p (e.symm b)) ↔ ∀ (b : β), q b
state_after: no goals
Theorem: Homeomorph.isCompact_preimage
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [← image_symm]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
s : Set Y
h : X ≃ₜ Y
⊢ IsCompact (⇑h ⁻¹' s) ↔ IsCompact s
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
s : Set Y
h : X ≃ₜ Y
⊢ IsCompact (⇑h.symm '' s) ↔ IsCompact s

tactic: exact h.symm.isCompact_image
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
s : Set Y
h : X ≃ₜ Y
⊢ IsCompact (⇑h.symm '' s) ↔ IsCompact s
state_after: no goals
Theorem: fderiv_inner_apply
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [(hf.hasFDerivAt.inner 𝕜 hg.hasFDerivAt).fderiv]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
y : G
⊢ (fderiv ℝ (fun t => ⟪f t, g t⟫_𝕜) x) y = ⟪f x, (fderiv ℝ g x) y⟫_𝕜 + ⟪(fderiv ℝ f x) y, g x⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
y : G
⊢ ((fderivInnerCLM 𝕜 (f x, g x)).comp ((fderiv ℝ f x).prod (fderiv ℝ g x))) y =
    ⟪f x, (fderiv ℝ g x) y⟫_𝕜 + ⟪(fderiv ℝ f x) y, g x⟫_𝕜

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
y : G
⊢ ((fderivInnerCLM 𝕜 (f x, g x)).comp ((fderiv ℝ f x).prod (fderiv ℝ g x))) y =
    ⟪f x, (fderiv ℝ g x) y⟫_𝕜 + ⟪(fderiv ℝ f x) y, g x⟫_𝕜
state_after: no goals
Theorem: NormedAddGroupHom.completion_comp
File: Mathlib/Analysis/Normed/Group/HomCompletion.lean

tactic: ext x
state_before: G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : NormedAddGroupHom H K
⊢ g.completion.comp f.completion = (g.comp f).completion
state_after: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : NormedAddGroupHom H K
x : Completion G
⊢ (g.completion.comp f.completion) x = (g.comp f).completion x

tactic: rw [NormedAddGroupHom.coe_comp, NormedAddGroupHom.completion_def,
  NormedAddGroupHom.completion_coe_to_fun, NormedAddGroupHom.completion_coe_to_fun,
  Completion.map_comp g.uniformContinuous f.uniformContinuous]
state_before: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : NormedAddGroupHom H K
x : Completion G
⊢ (g.completion.comp f.completion) x = (g.comp f).completion x
state_after: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : NormedAddGroupHom H K
x : Completion G
⊢ Completion.map (⇑g ∘ ⇑f) x = Completion.map (⇑(g.comp f)) x

tactic: rfl
state_before: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : NormedAddGroupHom H K
x : Completion G
⊢ Completion.map (⇑g ∘ ⇑f) x = Completion.map (⇑(g.comp f)) x
state_after: no goals
Theorem: ContinuousMultilinearMap.changeOriginSeries_support
File: Mathlib/Analysis/Calculus/FDeriv/Analytic.lean

tactic: simp_rw [FormalMultilinearSeries.changeOriginSeriesTerm,
  toFormalMultilinearSeries, dif_neg h.symm, LinearIsometryEquiv.map_zero]
state_before: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
k l : ℕ
h : k + l ≠ Fintype.card ι
x✝¹ : { s // s.card = l }
x✝ : x✝¹ ∈ Finset.univ
⊢ f.toFormalMultilinearSeries.changeOriginSeriesTerm k l ↑x✝¹ ⋯ = 0
state_after: no goals
Theorem: Complex.arg_neg_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp [arg, le_refl]
state_before: a x z : ℂ
⊢ (-I).arg = -(π / 2)
state_after: no goals
Theorem: SimpleGraph.Subgraph.iInf_adj_of_nonempty
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: rw [iInf, sInf_adj_of_nonempty (Set.range_nonempty _)]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
inst✝ : Nonempty ι
f : ι → G.Subgraph
⊢ (⨅ i, f i).Adj a b ↔ ∀ (i : ι), (f i).Adj a b
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
inst✝ : Nonempty ι
f : ι → G.Subgraph
⊢ (∀ G' ∈ Set.range fun i => f i, G'.Adj a b) ↔ ∀ (i : ι), (f i).Adj a b

tactic: simp
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
inst✝ : Nonempty ι
f : ι → G.Subgraph
⊢ (∀ G' ∈ Set.range fun i => f i, G'.Adj a b) ↔ ∀ (i : ι), (f i).Adj a b
state_after: no goals
Theorem: Fin.pred_lt_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← succ_lt_succ_iff, succ_pred]
state_before: n m : ℕ
j : Fin n
i : Fin (n + 1)
hi : i ≠ 0
⊢ i.pred hi < j ↔ i < j.succ
state_after: no goals
Theorem: HomotopyCategory.quotient_obj_mem_subcategoryAcyclic_iff_exactAt
File: Mathlib/Algebra/Homology/DerivedCategory/Basic.lean

tactic: rw [mem_subcategoryAcyclic_iff]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
⊢ (subcategoryAcyclic C).P ((quotient C (ComplexShape.up ℤ)).obj K) ↔ ∀ (n : ℤ), HomologicalComplex.ExactAt K n
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
⊢ (∀ (n : ℤ), IsZero ((homologyFunctor C (ComplexShape.up ℤ) n).obj ((quotient C (ComplexShape.up ℤ)).obj K))) ↔
    ∀ (n : ℤ), HomologicalComplex.ExactAt K n

tactic: refine forall_congr' (fun n => ?_)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
⊢ (∀ (n : ℤ), IsZero ((homologyFunctor C (ComplexShape.up ℤ) n).obj ((quotient C (ComplexShape.up ℤ)).obj K))) ↔
    ∀ (n : ℤ), HomologicalComplex.ExactAt K n
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
n : ℤ
⊢ IsZero ((homologyFunctor C (ComplexShape.up ℤ) n).obj ((quotient C (ComplexShape.up ℤ)).obj K)) ↔
    HomologicalComplex.ExactAt K n

tactic: simp only [HomologicalComplex.exactAt_iff_isZero_homology]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
n : ℤ
⊢ IsZero ((homologyFunctor C (ComplexShape.up ℤ) n).obj ((quotient C (ComplexShape.up ℤ)).obj K)) ↔
    HomologicalComplex.ExactAt K n
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
n : ℤ
⊢ IsZero ((homologyFunctor C (ComplexShape.up ℤ) n).obj ((quotient C (ComplexShape.up ℤ)).obj K)) ↔
    IsZero (HomologicalComplex.homology K n)

tactic: exact ((homologyFunctorFactors C (ComplexShape.up ℤ) n).app K).isZero_iff
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
K : CochainComplex C ℤ
n : ℤ
⊢ IsZero ((homologyFunctor C (ComplexShape.up ℤ) n).obj ((quotient C (ComplexShape.up ℤ)).obj K)) ↔
    IsZero (HomologicalComplex.homology K n)
state_after: no goals