tasksource/leandojo huggingface dataset:
Theorem: Real.Wallis.le_W
File: Mathlib/Data/Real/Pi/Wallis.lean

tactic: rw [← le_div_iff pi_div_two_pos, div_eq_inv_mul (W k) _]
state_before: k : ℕ
⊢ (2 * ↑k + 1) / (2 * ↑k + 2) * (π / 2) ≤ W k

tactic: rw [W_eq_integral_sin_pow_div_integral_sin_pow, le_div_iff (integral_sin_pow_pos _)]
state_before: k : ℕ
⊢ (2 * ↑k + 1) / (2 * ↑k + 2) ≤ (π / 2)⁻¹ * W k

tactic: convert integral_sin_pow_succ_le (2 * k + 1)
state_before: k : ℕ
⊢ ((2 * ↑k + 1) / (2 * ↑k + 2) * ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)) ≤ ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k + 1)

tactic: rw [integral_sin_pow (2 * k)]
state_before: case h.e'_3
k : ℕ
⊢ ((2 * ↑k + 1) / (2 * ↑k + 2) * ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)) = ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k + 1 + 1)

tactic: simp only [sin_zero, zero_pow', Ne.def, Nat.succ_ne_zero, zero_mul, sin_pi, tsub_zero, zero_div,
  zero_add]
state_before: case h.e'_3
k : ℕ
⊢ ((2 * ↑k + 1) / (2 * ↑k + 2) * ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)) =
    (sin 0 ^ (2 * k + 1) * cos 0 - sin π ^ (2 * k + 1) * cos π) / (↑(2 * k) + 2) +
      (↑(2 * k) + 1) / (↑(2 * k) + 2) * ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)

tactic: norm_cast
state_before: case h.e'_3
k : ℕ
⊢ ((2 * ↑k + 1) / (2 * ↑k + 2) * ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)) =
    (↑(2 * k) + 1) / (↑(2 * k) + 2) * ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)
Theorem: Equiv.Perm.cycleType_of_card_le_mem_cycleType_add_two
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: obtain ⟨c, g', rfl, hd, hc, rfl⟩ := mem_cycleType_iff.1 hng
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
n : ℕ
g : Perm α
hn2 : Fintype.card α < n + 2
hng : n ∈ cycleType g
⊢ cycleType g = {n}

tactic: by_cases g'1 : g' = 1
state_before: case intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
c g' : Perm α
hd : Disjoint c g'
hc : IsCycle c
hn2 : Fintype.card α < Finset.card (support c) + 2
hng : Finset.card (support c) ∈ cycleType (c * g')
⊢ cycleType (c * g') = {Finset.card (support c)}

tactic: contrapose! hn2
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
c g' : Perm α
hd : Disjoint c g'
hc : IsCycle c
hn2 : Fintype.card α < Finset.card (support c) + 2
hng : Finset.card (support c) ∈ cycleType (c * g')
g'1 : ¬g' = 1
⊢ cycleType (c * g') = {Finset.card (support c)}

tactic: apply le_trans _ (c * g').support.card_le_univ
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
c g' : Perm α
hd : Disjoint c g'
hc : IsCycle c
hng : Finset.card (support c) ∈ cycleType (c * g')
g'1 : ¬g' = 1
hn2 : cycleType (c * g') ≠ {Finset.card (support c)}
⊢ Finset.card (support c) + 2 ≤ Fintype.card α

tactic: rw [hd.card_support_mul]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
c g' : Perm α
hd : Disjoint c g'
hc : IsCycle c
hng : Finset.card (support c) ∈ cycleType (c * g')
g'1 : ¬g' = 1
hn2 : cycleType (c * g') ≠ {Finset.card (support c)}
⊢ Finset.card (support c) + 2 ≤ Finset.card (support (c * g'))

tactic: exact add_le_add_left (two_le_card_support_of_ne_one g'1) _
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
c g' : Perm α
hd : Disjoint c g'
hc : IsCycle c
hng : Finset.card (support c) ∈ cycleType (c * g')
g'1 : ¬g' = 1
hn2 : cycleType (c * g') ≠ {Finset.card (support c)}
⊢ Finset.card (support c) + 2 ≤ Finset.card (support c) + Finset.card (support g')

tactic: rw [hd.cycleType, hc.cycleType, coe_singleton, g'1, cycleType_one, add_zero]
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
c g' : Perm α
hd : Disjoint c g'
hc : IsCycle c
hn2 : Fintype.card α < Finset.card (support c) + 2
hng : Finset.card (support c) ∈ cycleType (c * g')
g'1 : g' = 1
⊢ cycleType (c * g') = {Finset.card (support c)}
Theorem: wittStructureRat_prop
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: rw [bind₁_bind₁]
state_before: p : ℕ
R : Type ?u.65060
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ ↑(bind₁ (wittStructureRat p Φ)) (W_ ℚ n) =
    ↑(bind₁ fun k => ↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℚ k)) Φ) (↑(bind₁ (xInTermsOfW p ℚ)) (W_ ℚ n))

tactic: exact eval₂Hom_congr (RingHom.ext_rat _ _) rfl rfl
state_before: p : ℕ
R : Type ?u.65060
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ ↑(bind₁ (wittStructureRat p Φ)) (W_ ℚ n) =
    ↑(bind₁ fun i => ↑(bind₁ fun k => ↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℚ k)) Φ) (xInTermsOfW p ℚ i)) (W_ ℚ n)

tactic: rw [bind₁_xInTermsOfW_wittPolynomial p _ n, bind₁_X_right]
state_before: p : ℕ
R : Type ?u.65060
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ ↑(bind₁ fun k => ↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℚ k)) Φ) (↑(bind₁ (xInTermsOfW p ℚ)) (W_ ℚ n)) =
    ↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℚ n)) Φ
Theorem: CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered
File: Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean

tactic: classical exact ⟨fun F => HasColimit.mk (liftToFinsetColimitCocone F)⟩
state_before: C : Type u
inst✝² : Category C
α✝ : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize C
α : Type w
⊢ HasColimitsOfShape (Discrete α) C

tactic: exact ⟨fun F => HasColimit.mk (liftToFinsetColimitCocone F)⟩
state_before: C : Type u
inst✝² : Category C
α✝ : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize C
α : Type w
⊢ HasColimitsOfShape (Discrete α) C
Theorem: StateT.run_seq
File: src/lean/Init/Control/Lawful.lean

tactic: show (f >>= fun g => g <$> x).run s = _
state_before: m : Type u → Type u_1
α β σ : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : StateT σ m (α → β)
x : StateT σ m α
s : σ
⊢ run (Seq.seq f fun x_1 => x) s = do
    let fs ← run f s
    (fun p => (Prod.fst fs p.fst, p.snd)) <$> run x fs.snd

tactic: simp
state_before: m : Type u → Type u_1
α β σ : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : StateT σ m (α → β)
x : StateT σ m α
s : σ
⊢ run
      (do
        let g ← f
        g <$> x)
      s =
    do
    let fs ← run f s
    (fun p => (Prod.fst fs p.fst, p.snd)) <$> run x fs.snd
Theorem: div_mul_cancel'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, inv_mul_cancel_right a b]
state_before: α : Type ?u.56920
β : Type ?u.56923
G : Type u_1
inst✝ : Group G
a✝ b✝ c d a b : G
⊢ a / b * b = a
Theorem: intervalIntegral.intervalIntegrable_inv_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: field_simp
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ IntervalIntegrable (fun x => (1 + x ^ 2)⁻¹) μ a b

tactic: exact_mod_cast intervalIntegrable_one_div_one_add_sq
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ IntervalIntegrable (fun x => 1 / (1 + x ^ 2)) μ a b
Theorem: Subgroup.map_subtype_le_map_subtype
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: apply Subtype.coe_injective
state_before: G : Type u_1
G'✝ : Type ?u.596430
inst✝³ : Group G
inst✝² : Group G'✝
A : Type ?u.596439
inst✝¹ : AddGroup A
N : Type ?u.596445
inst✝ : Group N
f : G →* N
G' : Subgroup G
H K : Subgroup { x // x ∈ G' }
⊢ Injective ↑(Subgroup.subtype G')
Theorem: Complex.tendsto_arg_nhdsWithin_im_neg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: suffices H :
  Tendsto (fun x : ℂ => Real.arcsin ((-x).im / abs x) - π) (𝓝[{ z : ℂ | z.im < 0 }] z) (𝓝 (-π))
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto arg (𝓝[{z | z.im < 0}] z) (𝓝 (-π))

tactic: convert (Real.continuousAt_arcsin.comp_continuousWithinAt
        ((continuous_im.continuousAt.comp_continuousWithinAt continuousWithinAt_neg).div
          continuous_abs.continuousWithinAt (s := { z : ℂ | z.im < 0 }) (_ : abs z ≠ 0))
        ).sub_const π using 1
state_before: case H
x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto (fun x => arcsin ((-x).im / ↑abs x) - π) (𝓝[{z | z.im < 0}] z) (𝓝 (-π))

tactic: refine' H.congr' _
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
H : Tendsto (fun x => arcsin ((-x).im / ↑abs x) - π) (𝓝[{z | z.im < 0}] z) (𝓝 (-π))
⊢ Tendsto arg (𝓝[{z | z.im < 0}] z) (𝓝 (-π))

tactic: have : ∀ᶠ x : ℂ in 𝓝 z, x.re < 0 := continuous_re.tendsto z (gt_mem_nhds hre)
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
H : Tendsto (fun x => arcsin ((-x).im / ↑abs x) - π) (𝓝[{z | z.im < 0}] z) (𝓝 (-π))
⊢ (fun x => arcsin ((-x).im / ↑abs x) - π) =ᶠ[𝓝[{z | z.im < 0}] z] arg

tactic: filter_upwards [self_mem_nhdsWithin (s := { z : ℂ | z.im < 0 }),
  mem_nhdsWithin_of_mem_nhds this] with _ him hre
state_before: x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
H : Tendsto (fun x => arcsin ((-x).im / ↑abs x) - π) (𝓝[{z | z.im < 0}] z) (𝓝 (-π))
this : ∀ᶠ (x : ℂ) in 𝓝 z, x.re < 0
⊢ (fun x => arcsin ((-x).im / ↑abs x) - π) =ᶠ[𝓝[{z | z.im < 0}] z] arg

tactic: rw [arg, if_neg hre.not_le, if_neg him.not_le]
state_before: case h
x z✝ z : ℂ
hre✝ : z.re < 0
him✝ : z.im = 0
H : Tendsto (fun x => arcsin ((-x).im / ↑abs x) - π) (𝓝[{z | z.im < 0}] z) (𝓝 (-π))
this : ∀ᶠ (x : ℂ) in 𝓝 z, x.re < 0
a✝ : ℂ
him : a✝.im < 0
hre : a✝.re < 0
⊢ arcsin ((-a✝).im / ↑abs a✝) - π = arg a✝

tactic: simp [him]
state_before: case h.e'_5
x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ 𝓝 (-π) = 𝓝 ((arcsin ∘ (im ∘ Neg.neg / ↑abs)) z - π)

tactic: lift z to ℝ using him
state_before: case H
x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ ↑abs z ≠ 0

tactic: simpa using hre.ne
state_before: case H.intro
x z✝ : ℂ
z : ℝ
hre : (↑z).re < 0
⊢ ↑abs ↑z ≠ 0
Theorem: SimpleGraph.reachable_iff_exists_finsetWalkLength_nonempty
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
⊢ Reachable G u v ↔ ∃ n, Finset.Nonempty (finsetWalkLength G (↑n) u v)

tactic: intro r
state_before: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
⊢ Reachable G u v → ∃ n, Finset.Nonempty (finsetWalkLength G (↑n) u v)

tactic: refine r.elim_path fun p => ?_
state_before: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
r : Reachable G u v
⊢ ∃ n, Finset.Nonempty (finsetWalkLength G (↑n) u v)

tactic: refine ⟨⟨_, p.isPath.length_lt⟩, p, ?_⟩
state_before: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
r : Reachable G u v
p : Path G u v
⊢ ∃ n, Finset.Nonempty (finsetWalkLength G (↑n) u v)

tactic: simp [Walk.mem_finsetWalkLength_iff_length_eq]
state_before: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
r : Reachable G u v
p : Path G u v
⊢ ↑p ∈ finsetWalkLength G (↑{ val := Walk.length ↑p, isLt := (_ : Walk.length ↑p < Fintype.card V) }) u v

tactic: rintro ⟨_, p, _⟩
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
⊢ (∃ n, Finset.Nonempty (finsetWalkLength G (↑n) u v)) → Reachable G u v

tactic: exact ⟨p⟩
state_before: case mpr.intro.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
w✝ : Fin (Fintype.card V)
p : Walk G u v
h✝ : p ∈ finsetWalkLength G (↑w✝) u v
⊢ Reachable G u v
Theorem: List.tail_append_singleton_of_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: induction l
state_before: ι : Type ?u.43325
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
h : l ≠ []
⊢ tail (l ++ [a]) = tail l ++ [a]

tactic: contradiction
state_before: case nil
ι : Type ?u.43325
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
h : [] ≠ []
⊢ tail ([] ++ [a]) = tail [] ++ [a]

case cons
ι : Type ?u.43325
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
tail_ih✝ : tail✝ ≠ [] → tail (tail✝ ++ [a]) = tail tail✝ ++ [a]
h : head✝ :: tail✝ ≠ []
⊢ tail (head✝ :: tail✝ ++ [a]) = tail (head✝ :: tail✝) ++ [a]

tactic: rw [tail, cons_append, tail]
state_before: case cons
ι : Type ?u.43325
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
tail_ih✝ : tail✝ ≠ [] → tail (tail✝ ++ [a]) = tail tail✝ ++ [a]
h : head✝ :: tail✝ ≠ []
⊢ tail (head✝ :: tail✝ ++ [a]) = tail (head✝ :: tail✝) ++ [a]
Theorem: Behrend.bound_aux
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: convert bound_aux' n d using 1
state_before: α : Type ?u.578354
β : Type ?u.578357
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (↑n - 2) / ↑n ≤ ↑(↑rothNumberNat ((2 * d - 1) ^ n))

tactic: rw [cast_mul, cast_pow, mul_comm, ← div_div, ← cast_two, ← cast_sub hn, rpow_nat_cast,
  rpow_nat_cast, pow_sub₀ _ (cast_ne_zero.2 hd) hn, ← div_eq_mul_inv]
state_before: case h.e'_3
α : Type ?u.578354
β : Type ?u.578357
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (↑n - 2) / ↑n = ↑d ^ ↑n / ↑(n * d ^ 2)
Theorem: Real.exp_eq_exp_ℝ
File: Mathlib/Analysis/SpecialFunctions/Exponential.lean

tactic: ext x
state_before: ⊢ exp = _root_.exp ℝ

tactic: exact_mod_cast congr_fun Complex.exp_eq_exp_ℂ x
state_before: case h
x : ℝ
⊢ exp x = _root_.exp ℝ x
Theorem: swap_dist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: funext x y
state_before: α : Type u
β : Type v
X : Type ?u.14808
ι : Type ?u.14811
inst✝ : PseudoMetricSpace α
⊢ Function.swap dist = dist

tactic: exact dist_comm _ _
state_before: case h.h
α : Type u
β : Type v
X : Type ?u.14808
ι : Type ?u.14811
inst✝ : PseudoMetricSpace α
x y : α
⊢ Function.swap dist x y = dist x y
Theorem: hnot_le_iff_codisjoint_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← top_sdiff', sdiff_le_iff, codisjoint_iff_le_sup]
state_before: ι : Type ?u.172893
α : Type u_1
β : Type ?u.172899
inst✝ : CoheytingAlgebra α
a b c : α
⊢ ￢a ≤ b ↔ Codisjoint a b
Theorem: List.replaceF_cons_of_some
File: Std/Data/List/Lemmas.lean

tactic: simp [replaceF_cons, h]
state_before: α : Type u_1
a' a : α
l : List α
p : α → Option α
h : p a = some a'
⊢ replaceF p (a :: l) = a' :: l
Theorem: tendsto_exp_div_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: cases' archimedean_iff_nat_lt.1 Real.instArchimedean s with n hn
state_before: s : ℝ
⊢ Tendsto (fun x => exp x / x ^ s) atTop atTop

tactic: refine' tendsto_atTop_mono' _ _ (tendsto_exp_div_pow_atTop n)
state_before: case intro
s : ℝ
n : ℕ
hn : s < ↑n
⊢ Tendsto (fun x => exp x / x ^ s) atTop atTop

tactic: filter_upwards [eventually_gt_atTop (0 : ℝ), eventually_ge_atTop (1 : ℝ)]with x hx₀ hx₁
state_before: case intro
s : ℝ
n : ℕ
hn : s < ↑n
⊢ (fun x => exp x / x ^ n) ≤ᶠ[atTop] fun x => exp x / x ^ s

tactic: rw [div_le_div_left (exp_pos _) (pow_pos hx₀ _) (rpow_pos_of_pos hx₀ _), ← Real.rpow_nat_cast]
state_before: case h
s : ℝ
n : ℕ
hn : s < ↑n
x : ℝ
hx₀ : 0 < x
hx₁ : 1 ≤ x
⊢ exp x / x ^ n ≤ exp x / x ^ s

tactic: exact rpow_le_rpow_of_exponent_le hx₁ hn.le
state_before: case h
s : ℝ
n : ℕ
hn : s < ↑n
x : ℝ
hx₀ : 0 < x
hx₁ : 1 ≤ x
⊢ x ^ s ≤ x ^ ↑n
Theorem: separatedNhds_iff_disjoint
File: Mathlib/Topology/Separation.lean

tactic: simp only [(hasBasis_nhdsSet s).disjoint_iff (hasBasis_nhdsSet t), SeparatedNhds, exists_prop, ←
  exists_and_left, and_assoc, and_comm, and_left_comm]
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
s t : Set α
⊢ SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t)
Theorem: HasFPowerSeriesOnBall.comp_sub
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: convert hf.hasSum hz using 2
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.408332
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ HasSum (fun n => ↑(p n) fun x => z) (f (x + y + z - y))

tactic: abel
state_before: case h.e'_6.h.e'_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.408332
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y z : E
hz : z ∈ EMetric.ball 0 r
⊢ x + y + z - y = x + z
Theorem: Part.toOption_eq_some_iff
File: Mathlib/Data/Part.lean

tactic: rw [← Option.mem_def, mem_toOption]
state_before: α : Type u_1
β : Type ?u.7998
γ : Type ?u.8001
o : Part α
inst✝ : Decidable o.Dom
a : α
⊢ toOption o = Option.some a ↔ a ∈ o
Theorem: Finset.sup_sigma
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp only [le_antisymm_iff, Finset.sup_le_iff, mem_sigma, and_imp, Sigma.forall]
state_before: ι : Type u_2
α : ι → Type u_3
β : Type u_1
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
f : (i : ι) × α i → β
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
⊢ sup (Finset.sigma s t) f = sup s fun i => sup (t i) fun b => f { fst := i, snd := b }

tactic: exact
  ⟨fun i a hi ha => (le_sup hi).trans' <| le_sup (f := fun a => f ⟨i, a⟩) ha, fun i hi a ha =>
    le_sup <| mem_sigma.2 ⟨hi, ha⟩⟩
state_before: ι : Type u_2
α : ι → Type u_3
β : Type u_1
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
f : (i : ι) × α i → β
inst✝¹ : SemilatticeSup β
inst✝ : OrderBot β
⊢ (∀ (a : ι) (b : α a),
      a ∈ s → b ∈ t a → f { fst := a, snd := b } ≤ sup s fun i => sup (t i) fun b => f { fst := i, snd := b }) ∧
    ∀ (b : ι), b ∈ s → ∀ (b_1 : α b), b_1 ∈ t b → f { fst := b, snd := b_1 } ≤ sup (Finset.sigma s t) f
Theorem: HahnSeries.order_neg
File: Mathlib/RingTheory/HahnSeries.lean

tactic: by_cases hf : f = 0
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
⊢ order (-f) = order f

tactic: simp only [order, support_neg, neg_eq_zero]
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : ¬f = 0
⊢ order (-f) = order f

tactic: simp only [hf, neg_zero]
state_before: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : f = 0
⊢ order (-f) = order f
Theorem: Fin.snoc_comp_cast_add
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: unfold comp
state_before: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i : Fin n✝
y : α✝ (↑castSucc i)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (n + m) → α
a : α
⊢ ∀ (x : Fin n), (snoc f a ∘ ↑(castAdd (m + 1))) x = (f ∘ ↑(castAdd m)) x

tactic: exact snoc_cast_add _ _
state_before: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i : Fin n✝
y : α✝ (↑castSucc i)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (n + m) → α
a : α
⊢ ∀ (x : Fin n), snoc f a (↑(castAdd (m + 1)) x) = f (↑(castAdd m) x)
Theorem: disjoint_assoc
File: Mathlib/Order/Disjoint.lean

tactic: rw [disjoint_iff_inf_le, disjoint_iff_inf_le, inf_assoc]
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
a b c d : α
⊢ Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c)
Theorem: stronglyMeasurableAt_bot
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
E : Type ?u.573263
F : Type ?u.573266
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
l l' : Filter α
f✝ g : α → β
μ ν : MeasureTheory.Measure α
f : α → β
⊢ AEStronglyMeasurable f (Measure.restrict μ ∅)
Theorem: PowerSeries.coeff_trunc
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp [trunc, Polynomial.coeff_sum, Polynomial.coeff_monomial, Nat.lt_succ_iff]
state_before: R : Type u_1
inst✝ : CommSemiring R
m n : ℕ
φ : PowerSeries R
⊢ Polynomial.coeff (trunc n φ) m = if m < n then ↑(coeff R m) φ else 0
Theorem: IsUnit.mul_inv_cancel
File: Mathlib/Algebra/Group/Units.lean

tactic: rintro ⟨u, rfl⟩
state_before: α : Type u
M : Type u_1
N : Type ?u.68821
inst✝ : DivisionMonoid M
a : M
⊢ IsUnit a → a * a⁻¹ = 1

tactic: rw [← Units.val_inv_eq_inv_val, Units.mul_inv]
state_before: case intro
α : Type u
M : Type u_1
N : Type ?u.68821
inst✝ : DivisionMonoid M
u : Mˣ
⊢ ↑u * (↑u)⁻¹ = 1
Theorem: Nat.find_le_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: simp only [exists_prop, ← lt_succ_iff, find_lt_iff]
state_before: m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n : ℕ
⊢ Nat.find h ≤ n ↔ ∃ m, m ≤ n ∧ p m
Theorem: Matrix.det_le
File: Mathlib/LinearAlgebra/Matrix/AbsoluteValue.lean

tactic: rw [abv.map_units_int_smul, abv.map_prod]
state_before: R : Type u_2
S : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Nontrivial R
inst✝² : LinearOrderedCommRing S
n : Type u_1
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n R
abv : AbsoluteValue R S
x : S
hx : ∀ (i j : n), ↑abv (A i j) ≤ x
σ : Perm n
x✝ : σ ∈ univ
⊢ ↑abv (↑Perm.sign σ • ∏ i : n, A (↑σ i) i) = ∏ i : n, ↑abv (A (↑σ i) i)

tactic: rw [prod_const, Finset.card_univ]
state_before: R : Type u_2
S : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Nontrivial R
inst✝² : LinearOrderedCommRing S
n : Type u_1
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n R
abv : AbsoluteValue R S
x : S
hx : ∀ (i j : n), ↑abv (A i j) ≤ x
x✝¹ : Perm n
x✝ : x✝¹ ∈ univ
⊢ ∏ _i : n, x = x ^ Fintype.card n

tactic: rw [sum_const, Finset.card_univ, Fintype.card_perm]
state_before: R : Type u_2
S : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Nontrivial R
inst✝² : LinearOrderedCommRing S
n : Type u_1
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n R
abv : AbsoluteValue R S
x : S
hx : ∀ (i j : n), ↑abv (A i j) ≤ x
⊢ ∑ _σ : Perm n, x ^ Fintype.card n = Nat.factorial (Fintype.card n) • x ^ Fintype.card n
Theorem: nhdsWithin_inter_of_mem
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin_inter, inf_eq_right]
state_before: α : Type u_1
β : Type ?u.18144
γ : Type ?u.18147
δ : Type ?u.18150
inst✝ : TopologicalSpace α
a : α
s t : Set α
h : s ∈ 𝓝[t] a
⊢ 𝓝[s ∩ t] a = 𝓝[t] a

tactic: exact nhdsWithin_le_of_mem h
state_before: α : Type u_1
β : Type ?u.18144
γ : Type ?u.18147
δ : Type ?u.18150
inst✝ : TopologicalSpace α
a : α
s t : Set α
h : s ∈ 𝓝[t] a
⊢ 𝓝[t] a ≤ 𝓝[s] a
Theorem: Finsupp.mapRange_neg
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [hf', neg_apply, mapRange_apply]
state_before: α : Type u_3
β : Type ?u.422976
γ : Type ?u.422979
ι : Type ?u.422982
M : Type ?u.422985
M' : Type ?u.422988
N : Type ?u.422991
P : Type ?u.422994
G : Type u_1
H : Type u_2
R : Type ?u.423003
S : Type ?u.423006
inst✝¹ : NegZeroClass G
inst✝ : NegZeroClass H
f : G → H
hf : f 0 = 0
hf' : ∀ (x : G), f (-x) = -f x
v : α →₀ G
x✝ : α
⊢ ↑(mapRange f hf (-v)) x✝ = ↑(-mapRange f hf v) x✝
Theorem: IsCoprime.pow_right
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: rw [← Finset.card_range n, ← Finset.prod_const]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime x (y ^ n)

tactic: exact IsCoprime.prod_right fun _ _ ↦ H
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime x (∏ _x in range n, y)
Theorem: Finset.prod_dite_irrel
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: split_ifs with h <;> rfl
state_before: ι : Type ?u.418226
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
p : Prop
inst✝ : Decidable p
s : Finset α
f : p → α → β
g : ¬p → α → β
⊢ (∏ x in s, if h : p then f h x else g h x) = if h : p then ∏ x in s, f h x else ∏ x in s, g h x