tasksource/leandojo huggingface dataset:
Theorem: Polynomial.degreeLT_eq_span_X_pow
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: apply le_antisymm
state_before: R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
⊢ degreeLT R n = Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: rw [Submodule.span_le, Finset.coe_image, Set.image_subset_iff]
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
⊢ Submodule.span R ↑(image (fun n => X ^ n) (range n)) ≤ degreeLT R n

tactic: intro k hk
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
⊢ ↑(range n) ⊆ (fun n => X ^ n) ⁻¹' ↑(degreeLT R n)

tactic: apply mem_degreeLT.2
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n k : ℕ
hk : k ∈ ↑(range n)
⊢ k ∈ (fun n => X ^ n) ⁻¹' ↑(degreeLT R n)

tactic: exact lt_of_le_of_lt (degree_X_pow_le _) (WithBot.coe_lt_coe.2 <| Finset.mem_range.1 hk)
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n k : ℕ
hk : k ∈ ↑(range n)
⊢ degree ((fun n => X ^ n) k) < ↑n

tactic: intro p hp
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
⊢ degreeLT R n ≤ Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: replace hp := mem_degreeLT.1 hp
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : p ∈ degreeLT R n
⊢ p ∈ Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: rw [← Polynomial.sum_monomial_eq p, Polynomial.sum]
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p < ↑n
⊢ p ∈ Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: refine' Submodule.sum_mem _ fun k hk => _
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p < ↑n
⊢ ∑ n in support p, ↑(monomial n) (coeff p n) ∈ Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: have := WithBot.coe_lt_coe.1 ((Finset.sup_lt_iff <| WithBot.bot_lt_coe n).1 hp k hk)
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p < ↑n
k : ℕ
hk : k ∈ support p
⊢ ↑(monomial k) (coeff p k) ∈ Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: rw [← C_mul_X_pow_eq_monomial, C_mul']
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p < ↑n
k : ℕ
hk : k ∈ support p
this : k < n
⊢ ↑(monomial k) (coeff p k) ∈ Submodule.span R ↑(image (fun n => X ^ n) (range n))

tactic: refine'
  Submodule.smul_mem _ _
    (Submodule.subset_span <|
      Finset.mem_coe.2 <| Finset.mem_image.2 ⟨_, Finset.mem_range.2 this, rfl⟩)
state_before: case a
R : Type u
S : Type ?u.15171
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p < ↑n
k : ℕ
hk : k ∈ support p
this : k < n
⊢ coeff p k • X ^ k ∈ Submodule.span R ↑(image (fun n => X ^ n) (range n))
Theorem: padicNorm.padicNorm_p_lt_one
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: rw [padicNorm_p hp, inv_lt_one_iff]
state_before: p : ℕ
hp : 1 < p
⊢ padicNorm p ↑p < 1

tactic: exact_mod_cast Or.inr hp
state_before: p : ℕ
hp : 1 < p
⊢ ↑p ≤ 0 ∨ 1 < ↑p
Theorem: Qpf.corecF_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: rw [corecF, PFunctor.M.dest_corec]
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : α → F α
x : α
⊢ PFunctor.M.dest (corecF g x) = corecF g <$> repr (g x)
Theorem: continuous_sigma_iff
File: Mathlib/Topology/Constructions.lean

tactic: delta instTopologicalSpaceSigma
state_before: α : Type u
β : Type v
γ : Type ?u.528783
δ : Type ?u.528786
ε : Type ?u.528789
ζ : Type ?u.528792
ι : Type u_1
κ : Type ?u.528798
σ : ι → Type u_2
τ : κ → Type ?u.528808
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
f : Sigma σ → α
⊢ Continuous f ↔ ∀ (i : ι), Continuous fun a => f { fst := i, snd := a }

tactic: rw [continuous_iSup_dom]
state_before: α : Type u
β : Type v
γ : Type ?u.528783
δ : Type ?u.528786
ε : Type ?u.528789
ζ : Type ?u.528792
ι : Type u_1
κ : Type ?u.528798
σ : ι → Type u_2
τ : κ → Type ?u.528808
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
f : Sigma σ → α
⊢ Continuous f ↔ ∀ (i : ι), Continuous fun a => f { fst := i, snd := a }

tactic: exact forall_congr' fun _ => continuous_coinduced_dom
state_before: α : Type u
β : Type v
γ : Type ?u.528783
δ : Type ?u.528786
ε : Type ?u.528789
ζ : Type ?u.528792
ι : Type u_1
κ : Type ?u.528798
σ : ι → Type u_2
τ : κ → Type ?u.528808
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
f : Sigma σ → α
⊢ (∀ (i : ι), Continuous f) ↔ ∀ (i : ι), Continuous fun a => f { fst := i, snd := a }
Theorem: Padic.norm_le_one_iff_val_nonneg
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: by_cases hx : x = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
⊢ ‖x‖ ≤ 1 ↔ 0 ≤ valuation x

tactic: simp only [hx, norm_zero, valuation_zero, zero_le_one, le_refl]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
hx : x = 0
⊢ ‖x‖ ≤ 1 ↔ 0 ≤ valuation x

tactic: rw [norm_eq_pow_val hx, ← zpow_zero (p : ℝ), zpow_le_iff_le, Right.neg_nonpos_iff]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
hx : ¬x = 0
⊢ ‖x‖ ≤ 1 ↔ 0 ≤ valuation x

tactic: exact Nat.one_lt_cast.2 (Nat.Prime.one_lt' p).1
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
hx : ¬x = 0
⊢ 1 < ↑p
Theorem: LinearMap.polar_eq_iInter
File: Mathlib/Analysis/LocallyConvex/Polar.lean

tactic: ext
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
⊢ polar B s = ⋂ (x : E) (_ : x ∈ s), {y | ‖↑(↑B x) y‖ ≤ 1}

tactic: simp only [polar_mem_iff, Set.mem_iInter, Set.mem_setOf_eq]
state_before: case h
𝕜 : Type u_3
E : Type u_1
F : Type u_2
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
x✝ : F
⊢ x✝ ∈ polar B s ↔ x✝ ∈ ⋂ (x : E) (_ : x ∈ s), {y | ‖↑(↑B x) y‖ ≤ 1}
Theorem: Int.lcm_one_left
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm]
state_before: i : ℤ
⊢ lcm 1 i = natAbs i

tactic: apply Nat.lcm_one_left
state_before: i : ℤ
⊢ Nat.lcm (natAbs 1) (natAbs i) = natAbs i
Theorem: exists_pos_right_iff_sameRay_and_ne_zero
File: Mathlib/LinearAlgebra/Ray.lean

tactic: rw [SameRay.sameRay_comm]
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R x y ∧ x ≠ 0

tactic: simp_rw [eq_comm (a := x)]
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R y x ∧ x ≠ 0

tactic: exact exists_pos_left_iff_sameRay_and_ne_zero hy
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • y = x) ↔ SameRay R y x ∧ x ≠ 0
Theorem: ConvexOn.secant_mono_aux2
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have hxy' : 0 < y - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)

tactic: have hxz' : 0 < z - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)

tactic: rw [div_le_div_iff hxy' hxz']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
hxz' : 0 < z - x
⊢ (f y - f x) / (y - x) ≤ (f z - f x) / (z - x)

tactic: linarith only [hf.secant_mono_aux1 hx hz hxy hyz]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
hxz' : 0 < z - x
⊢ (f y - f x) * (z - x) ≤ (f z - f x) * (y - x)

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ 0 < y - x

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hxy' : 0 < y - x
⊢ 0 < z - x
Theorem: Cardinal.mk_fin
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α β : Type u
n : ℕ
⊢ (#Fin n) = ↑n
Theorem: isDedekindDomainInv_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: let h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K :=
  FractionalIdeal.mapEquiv (FractionRing.algEquiv A K)
state_before: R : Type ?u.96084
A : Type u_1
K : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsDedekindDomainInv A ↔ ∀ (I : FractionalIdeal A⁰ K), I ≠ ⊥ → I * I⁻¹ = 1

tactic: refine h.toEquiv.forall_congr (fun {x} => ?_)
state_before: R : Type ?u.96084
A : Type u_1
K : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
⊢ IsDedekindDomainInv A ↔ ∀ (I : FractionalIdeal A⁰ K), I ≠ ⊥ → I * I⁻¹ = 1

tactic: rw [← h.toEquiv.apply_eq_iff_eq]
state_before: R : Type ?u.96084
A : Type u_1
K : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
x : FractionalIdeal A⁰ (FractionRing A)
⊢ x ≠ ⊥ → x * x⁻¹ = 1 ↔ ↑h.toEquiv x ≠ ⊥ → ↑h.toEquiv x * (↑h.toEquiv x)⁻¹ = 1

tactic: simp [IsDedekindDomainInv]
state_before: R : Type ?u.96084
A : Type u_1
K : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
x : FractionalIdeal A⁰ (FractionRing A)
⊢ x ≠ ⊥ → ↑h.toEquiv (x * x⁻¹) = ↑h.toEquiv 1 ↔ ↑h.toEquiv x ≠ ⊥ → ↑h.toEquiv x * (↑h.toEquiv x)⁻¹ = 1
Theorem: Function.Periodic.nat_mul_sub_eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_neg_add] using h.nat_mul n (-x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.102914
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℕ
⊢ f (↑n * c - x) = f (-x)
Theorem: neg_one_geom_sum
File: Mathlib/Algebra/GeomSum.lean

tactic: induction' n with k hk
state_before: α : Type u
inst✝ : Ring α
n : ℕ
⊢ ∑ i in range n, (-1) ^ i = if Even n then 0 else 1

tactic: simp
state_before: case zero
α : Type u
inst✝ : Ring α
⊢ ∑ i in range Nat.zero, (-1) ^ i = if Even Nat.zero then 0 else 1

tactic: simp only [geom_sum_succ', Nat.even_add_one, hk]
state_before: case succ
α : Type u
inst✝ : Ring α
k : ℕ
hk : ∑ i in range k, (-1) ^ i = if Even k then 0 else 1
⊢ ∑ i in range (Nat.succ k), (-1) ^ i = if Even (Nat.succ k) then 0 else 1

tactic: split_ifs with h
state_before: case succ
α : Type u
inst✝ : Ring α
k : ℕ
hk : ∑ i in range k, (-1) ^ i = if Even k then 0 else 1
⊢ ((-1) ^ k + if Even k then 0 else 1) = if ¬Even k then 0 else 1

tactic: rw [h.neg_one_pow, add_zero]
state_before: case succ.inl
α : Type u
inst✝ : Ring α
k : ℕ
hk : ∑ i in range k, (-1) ^ i = if Even k then 0 else 1
h : Even k
⊢ (-1) ^ k + 0 = 1

tactic: rw [(Nat.odd_iff_not_even.2 h).neg_one_pow, neg_add_self]
state_before: case succ.inr
α : Type u
inst✝ : Ring α
k : ℕ
hk : ∑ i in range k, (-1) ^ i = if Even k then 0 else 1
h : ¬Even k
⊢ (-1) ^ k + 1 = 0
Theorem: Matrix.dotProduct_comm
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp_rw [dotProduct, mul_comm]
state_before: l : Type ?u.122679
m : Type u_1
n : Type ?u.122685
o : Type ?u.122688
m' : o → Type ?u.122693
n' : o → Type ?u.122698
R : Type ?u.122701
S : Type ?u.122704
α : Type v
β : Type w
γ : Type ?u.122711
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : AddCommMonoid α
inst✝ : CommSemigroup α
v w : m → α
⊢ v ⬝ᵥ w = w ⬝ᵥ v
Theorem: Nat.ArithmeticFunction.ppow_succ'
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext x
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
⊢ ppow f (k + 1) = pmul (ppow f k) f

tactic: rw [ppow_apply (Nat.succ_pos k), pow_succ'']
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
x : ℕ
⊢ ↑(ppow f (k + 1)) x = ↑(pmul (ppow f k) f) x

tactic: induction k <;> simp
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
k : ℕ
kpos : 0 < k
x : ℕ
⊢ ↑f x * ↑f x ^ k = ↑(pmul (ppow f k) f) x

tactic: rw [pow_mul_comm']
state_before: case h.succ
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x n✝ : ℕ
n_ih✝ : ∀ {kpos : 0 < n✝}, ↑f x * ↑f x ^ n✝ = ↑(pmul (ppow f n✝) f) x
kpos : 0 < succ n✝
⊢ ↑f x * ↑f x ^ succ n✝ = ↑f x ^ succ n✝ * ↑f x
Theorem: Real.log_div
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [exp_log_eq_abs (div_ne_zero hx hy), exp_sub, exp_log_eq_abs hx, exp_log_eq_abs hy, abs_div]
state_before: x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ exp (log (x / y)) = exp (log x - log y)
Theorem: AList.perm_insert
File: Mathlib/Data/List/AList.lean

tactic: simp only [insert_entries]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
p : s₁.entries ~ s₂.entries
⊢ (insert a b s₁).entries ~ (insert a b s₂).entries

tactic: exact p.kinsert s₁.nodupKeys
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : AList β
p : s₁.entries ~ s₂.entries
⊢ { fst := a, snd := b } :: kerase a s₁.entries ~ { fst := a, snd := b } :: kerase a s₂.entries
Theorem: IsLUB.mul_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rcases lt_or_eq_of_le ha with (ha | rfl)
state_before: ι : Type ?u.190062
α : Type u_1
β : Type ?u.190068
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
s : Set α
ha : 0 ≤ a
hs : IsLUB s b
⊢ IsLUB ((fun b => a * b) '' s) (a * b)

tactic: exact (OrderIso.mulLeft₀ _ ha).isLUB_image'.2 hs
state_before: case inl
ι : Type ?u.190062
α : Type u_1
β : Type ?u.190068
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsLUB s b
ha : 0 < a
⊢ IsLUB ((fun b => a * b) '' s) (a * b)

tactic: simp_rw [zero_mul]
state_before: case inr
ι : Type ?u.190062
α : Type u_1
β : Type ?u.190068
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB ((fun b => 0 * b) '' s) (0 * b)

tactic: rw [hs.nonempty.image_const]
state_before: case inr
ι : Type ?u.190062
α : Type u_1
β : Type ?u.190068
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB ((fun a => 0) '' s) 0

tactic: exact isLUB_singleton
state_before: case inr
ι : Type ?u.190062
α : Type u_1
β : Type ?u.190068
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
s : Set α
hs : IsLUB s b
ha : 0 ≤ 0
⊢ IsLUB {0} 0
Theorem: contDiffOn_top_iff_fderiv_of_open
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [contDiffOn_top_iff_fderivWithin hs.uniqueDiffOn]
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
hs : IsOpen s
⊢ ContDiffOn 𝕜 ⊤ f s ↔ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderiv 𝕜 f y) s

tactic: exact Iff.rfl.and <| contDiffOn_congr fun x hx ↦ fderivWithin_of_open hs hx
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
hs : IsOpen s
⊢ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s ↔
    DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderiv 𝕜 f y) s
Theorem: Equiv.Perm.card_support_extend_domain
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp
state_before: α : Type u_1
inst✝⁴ : DecidableEq α
inst✝³ : Fintype α
f✝ g✝ : Perm α
β : Type u_2
inst✝² : DecidableEq β
inst✝¹ : Fintype β
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
g : Perm α
⊢ card (support (extendDomain g f)) = card (support g)
Theorem: Valuation.IsEquiv.val_eq
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: simpa only [le_antisymm_iff] using and_congr (h r s) (h s r)
state_before: K : Type ?u.2929625
F : Type ?u.2929628
R : Type u_1
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type u_3
Γ''₀ : Type ?u.2929643
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
h : IsEquiv v₁ v₂
r s : R
⊢ ↑v₁ r = ↑v₁ s ↔ ↑v₂ r = ↑v₂ s
Theorem: Antivary.sum_smul_eq_sum_smul_comp_perm_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [(hfg.antivaryOn _).sum_smul_eq_sum_smul_comp_perm_iff fun _ _ ↦ mem_univ _]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Antivary f g
⊢ ∑ i : ι, f i • g (↑σ i) = ∑ i : ι, f i • g i ↔ Antivary f (g ∘ ↑σ)
Theorem: Real.ball_eq_Ioo
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [mem_ball, dist_comm, Real.dist_eq, abs_sub_lt_iff, mem_Ioo, ← sub_lt_iff_lt_add',
  sub_lt_comm]
state_before: α : Type u
β : Type v
X : Type ?u.198627
ι : Type ?u.198630
inst✝ : PseudoMetricSpace α
x r y : ℝ
⊢ y ∈ ball x r ↔ y ∈ Ioo (x - r) (x + r)
Theorem: mul_zpow_self
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [← zpow_add, add_comm]
state_before: α : Type ?u.129303
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
b : G
m : ℤ
⊢ b ^ m * b ^ 1 = b ^ (m + 1)
Theorem: List.Func.nil_pointwise
File: Mathlib/Data/List/Func.lean

tactic: simp only [nil_pointwise bs, pointwise, eq_self_iff_true, and_self_iff, map]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Inhabited α
inst✝ : Inhabited β
f : α → β → γ
b : β
bs : List β
⊢ pointwise f [] (b :: bs) = map (f default) (b :: bs)
Theorem: Cardinal.mk_toPartENat_eq_coe_card
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α β : Type u
inst✝ : Fintype α
⊢ ↑toPartENat (#α) = ↑(Fintype.card α)
Theorem: PadicInt.unitCoeff_spec
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: apply Subtype.coe_injective
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ x = ↑(unitCoeff hx) * ↑p ^ Int.natAbs (valuation x)

tactic: push_cast
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ (fun a => ↑a) x = (fun a => ↑a) (↑(unitCoeff hx) * ↑p ^ Int.natAbs (valuation x))

tactic: convert repr using 2
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
repr : ↑x = ↑↑(unitCoeff hx) * ↑p ^ valuation x
⊢ ↑x = ↑↑(unitCoeff hx) * ↑p ^ Int.natAbs (valuation x)

tactic: rw [← zpow_ofNat, Int.natAbs_of_nonneg (valuation_nonneg x)]
state_before: case h.e'_3.h.e'_6
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
repr : ↑x = ↑↑(unitCoeff hx) * ↑p ^ valuation x
⊢ ↑p ^ Int.natAbs (valuation x) = ↑p ^ valuation x

tactic: rw [unitCoeff_coe, mul_assoc, ← zpow_add₀]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x = ↑↑(unitCoeff hx) * ↑p ^ valuation x

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x = ↑x * ↑p ^ (-valuation x + valuation x)

tactic: exact_mod_cast hp.1.ne_zero
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑p ≠ 0
Theorem: CategoryTheory.Limits.map_lift_equalizerComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: simp only [← G.map_comp, w]
state_before: C : Type u
inst✝³ : Category C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ G.map h ≫ G.map f = G.map h ≫ G.map g

tactic: apply equalizer.hom_ext
state_before: C : Type u
inst✝³ : Category C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ G.map (equalizer.lift h w) ≫ equalizerComparison f g G =
    equalizer.lift (G.map h) (_ : G.map h ≫ G.map f = G.map h ≫ G.map g)

tactic: simp [← G.map_comp]
state_before: case h
C : Type u
inst✝³ : Category C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category D
G : C ⥤ D
inst✝¹ : HasEqualizer f g
inst✝ : HasEqualizer (G.map f) (G.map g)
Z : C
h : Z ⟶ X
w : h ≫ f = h ≫ g
⊢ (G.map (equalizer.lift h w) ≫ equalizerComparison f g G) ≫ equalizer.ι (G.map f) (G.map g) =
    equalizer.lift (G.map h) (_ : G.map h ≫ G.map f = G.map h ≫ G.map g) ≫ equalizer.ι (G.map f) (G.map g)
Theorem: IsLocalizedModule.mk'_one
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: delta mk'
state_before: R : Type u_2
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_1
M'' : Type ?u.826565
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
⊢ mk' f m 1 = ↑f m

tactic: rw [fromLocalizedModule_mk, Module.End_algebraMap_isUnit_inv_apply_eq_iff, Submonoid.coe_one,
  one_smul]
state_before: R : Type u_2
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_1
M'' : Type ?u.826565
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
⊢ ↑(fromLocalizedModule S f) (LocalizedModule.mk m 1) = ↑f m
Theorem: Equiv.induced_symm
File: Mathlib/Topology/Order.lean

tactic: ext t U
state_before: α✝ : Type ?u.26688
β✝ : Type ?u.26691
γ : Type ?u.26694
t t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_1
β : Type u_2
e : α ≃ β
⊢ TopologicalSpace.induced ↑e.symm = TopologicalSpace.coinduced ↑e

tactic: rw [isOpen_induced_iff, isOpen_coinduced]
state_before: case h.a.h.a
α✝ : Type ?u.26688
β✝ : Type ?u.26691
γ : Type ?u.26694
t✝ t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_1
β : Type u_2
e : α ≃ β
t : TopologicalSpace α
U : Set β
⊢ IsOpen U ↔ IsOpen U

tactic: simp only [e.symm.preimage_eq_iff_eq_image, exists_eq_right, ← preimage_equiv_eq_image_symm]
state_before: case h.a.h.a
α✝ : Type ?u.26688
β✝ : Type ?u.26691
γ : Type ?u.26694
t✝ t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_1
β : Type u_2
e : α ≃ β
t : TopologicalSpace α
U : Set β
⊢ (∃ t_1, IsOpen t_1 ∧ ↑e.symm ⁻¹' t_1 = U) ↔ IsOpen (↑e ⁻¹' U)
Theorem: IsOpen.frontier_eq
File: Mathlib/Topology/Basic.lean

tactic: rw [frontier, hs.interior_eq]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
hs : IsOpen s
⊢ frontier s = closure s \ s