tasksource/leandojo huggingface dataset:
Theorem: ENNReal.finset_card_const_le_le_of_tsum_le
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: have hf : { i : ι | ε ≤ a i }.Finite :=
  finite_const_le_of_tsum_ne_top (ne_top_of_le_ne_top c_ne_top tsum_le_c) ε_ne_zero
state_before: α : Type ?u.303162
β : Type ?u.303165
γ : Type ?u.303168
a✝ b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε✝ ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
a : ι → ℝ≥0∞
c : ℝ≥0∞
c_ne_top : c ≠ ⊤
tsum_le_c : (∑' (i : ι), a i) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
⊢ ∃ hf, ↑(Finset.card (Finite.toFinset hf)) ≤ c / ε

tactic: refine ⟨hf, (ENNReal.le_div_iff_mul_le (.inl ε_ne_zero) (.inr c_ne_top)).2 ?_⟩
state_before: α : Type ?u.303162
β : Type ?u.303165
γ : Type ?u.303168
a✝ b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε✝ ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
a : ι → ℝ≥0∞
c : ℝ≥0∞
c_ne_top : c ≠ ⊤
tsum_le_c : (∑' (i : ι), a i) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
hf : Set.Finite {i | ε ≤ a i}
⊢ ∃ hf, ↑(Finset.card (Finite.toFinset hf)) ≤ c / ε

tactic: calc ↑hf.toFinset.card * ε = ∑ _i in hf.toFinset, ε := by rw [Finset.sum_const, nsmul_eq_mul]
  _ ≤ ∑ i in hf.toFinset, a i := Finset.sum_le_sum fun i => hf.mem_toFinset.1
  _ ≤ ∑' i, a i := ENNReal.sum_le_tsum _
  _ ≤ c := tsum_le_c
state_before: α : Type ?u.303162
β : Type ?u.303165
γ : Type ?u.303168
a✝ b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε✝ ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
a : ι → ℝ≥0∞
c : ℝ≥0∞
c_ne_top : c ≠ ⊤
tsum_le_c : (∑' (i : ι), a i) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
hf : Set.Finite {i | ε ≤ a i}
⊢ ↑(Finset.card (Finite.toFinset hf)) * ε ≤ c

tactic: rw [Finset.sum_const, nsmul_eq_mul]
state_before: α : Type ?u.303162
β : Type ?u.303165
γ : Type ?u.303168
a✝ b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε✝ ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
a : ι → ℝ≥0∞
c : ℝ≥0∞
c_ne_top : c ≠ ⊤
tsum_le_c : (∑' (i : ι), a i) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
hf : Set.Finite {i | ε ≤ a i}
⊢ ↑(Finset.card (Finite.toFinset hf)) * ε = ∑ _i in Finite.toFinset hf, ε
Theorem: Complex.cos_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos]
state_before: x y : ℂ
⊢ cos 0 = 1
Theorem: CircleDeg1Lift.tendsto_translationNumber
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: rw [← translationNumber_conj_eq' (translate <| Multiplicative.ofAdd x)]
state_before: f g : CircleDeg1Lift
x : ℝ
⊢ Tendsto (fun n => (↑(f ^ n) x - x) / ↑n) atTop (𝓝 (τ f))

tactic: refine (tendsto_translation_number₀ _).congr fun n ↦ ?_
state_before: f g : CircleDeg1Lift
x : ℝ
⊢ Tendsto (fun n => (↑(f ^ n) x - x) / ↑n) atTop
    (𝓝 (τ (↑(↑translate (↑Multiplicative.ofAdd x))⁻¹ * f * ↑(↑translate (↑Multiplicative.ofAdd x)))))

tactic: simp [sub_eq_neg_add, Units.conj_pow']
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℕ
⊢ ↑((↑(↑translate (↑Multiplicative.ofAdd x))⁻¹ * f * ↑(↑translate (↑Multiplicative.ofAdd x))) ^ n) 0 / ↑n =
    (↑(f ^ n) x - x) / ↑n
Theorem: Filter.bind_inf_principal
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_bind, mem_inf_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.299000
ι : Sort x
f : Filter α
g : α → Filter β
s✝ s : Set β
⊢ (s ∈ bind f fun x => g x ⊓ 𝓟 s✝) ↔ s ∈ bind f g ⊓ 𝓟 s✝
Theorem: WittVector.wittAdd_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type ?u.56659
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittAdd p 0 = X (0, 0) + X (1, 0)

tactic: simp only [wittAdd, wittStructureRat, AlgHom.map_add, RingHom.map_add, rename_X,
  xInTermsOfW_zero, map_X, wittPolynomial_zero, bind₁_X_right, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type ?u.56659
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ ↑(map (Int.castRingHom ℚ)) (wittAdd p 0) = ↑(map (Int.castRingHom ℚ)) (X (0, 0) + X (1, 0))
Theorem: MeasureTheory.AEStronglyMeasurable.prod_mk_left
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: filter_upwards [ae_ae_of_ae_prod hf.ae_eq_mk] with x hx
state_before: α : Type u_3
α' : Type ?u.2388487
β : Type u_2
β' : Type ?u.2388493
γ✝ : Type ?u.2388496
E : Type ?u.2388499
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ✝
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ✝
inst✝² : NormedAddCommGroup E
γ : Type u_1
inst✝¹ : SigmaFinite ν
inst✝ : TopologicalSpace γ
f : α × β → γ
hf : AEStronglyMeasurable f (Measure.prod μ ν)
⊢ ∀ᵐ (x : α) ∂μ, AEStronglyMeasurable (fun y => f (x, y)) ν

tactic: exact
  ⟨fun y => hf.mk f (x, y), hf.stronglyMeasurable_mk.comp_measurable measurable_prod_mk_left, hx⟩
state_before: case h
α : Type u_3
α' : Type ?u.2388487
β : Type u_2
β' : Type ?u.2388493
γ✝ : Type ?u.2388496
E : Type ?u.2388499
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ✝
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ✝
inst✝² : NormedAddCommGroup E
γ : Type u_1
inst✝¹ : SigmaFinite ν
inst✝ : TopologicalSpace γ
f : α × β → γ
hf : AEStronglyMeasurable f (Measure.prod μ ν)
x : α
hx : ∀ᵐ (y : β) ∂ν, f (x, y) = AEStronglyMeasurable.mk f hf (x, y)
⊢ AEStronglyMeasurable (fun y => f (x, y)) ν
Theorem: Finsupp.antidiagonal_zero
File: Mathlib/Data/Finsupp/Antidiagonal.lean

tactic: rw [antidiagonal, antidiagonal', Multiset.toFinsupp_support]
state_before: α : Type u
⊢ antidiagonal 0 = {(0, 0)}

tactic: rfl
state_before: α : Type u
⊢ Multiset.toFinset
      (Multiset.map (Prod.map ↑Multiset.toFinsupp ↑Multiset.toFinsupp) (Multiset.antidiagonal (↑toMultiset 0))) =
    {(0, 0)}
Theorem: Commute.div_mul_div_comm
File: Mathlib/Algebra/Group/Commute.lean

tactic: simp_rw [div_eq_mul_inv, mul_inv_rev, hbd.inv_inv.symm.eq, hbc.mul_mul_mul_comm]
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b c d : G
hbd : Commute b d
hbc : Commute b⁻¹ c
⊢ a / b * (c / d) = a * c / (b * d)
Theorem: MeasureTheory.OuterMeasure.smul_dirac_apply
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp only [smul_apply, smul_eq_mul, dirac_apply, ← indicator_mul_right _ fun _ => a, mul_one]
state_before: α : Type u_1
β : Type ?u.88337
R : Type ?u.88340
R' : Type ?u.88343
ms : Set (OuterMeasure α)
m : OuterMeasure α
a : ℝ≥0∞
b : α
s : Set α
⊢ ↑(a • dirac b) s = indicator s (fun x => a) b
Theorem: Ordinal.add_omega_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine' le_antisymm _ (le_add_left _ _)
state_before: a b : Ordinal
h : a < ω ^ b
⊢ a + ω ^ b = ω ^ b

tactic: induction' b using limitRecOn with b _ b l IH
state_before: a b : Ordinal
h : a < ω ^ b
⊢ a + ω ^ b ≤ ω ^ b

tactic: rw [opow_zero, ← succ_zero, lt_succ_iff, Ordinal.le_zero] at h
state_before: case H₁
a b : Ordinal
h✝ : a < ω ^ b
h : a < ω ^ 0
⊢ a + ω ^ 0 ≤ ω ^ 0

tactic: rw [h, zero_add]
state_before: case H₁
a b : Ordinal
h✝ : a < ω ^ b
h : a = 0
⊢ a + ω ^ 0 ≤ ω ^ 0

tactic: rw [opow_succ] at h
state_before: case H₂
a b✝ : Ordinal
h✝ : a < ω ^ b✝
b : Ordinal
a✝ : a < ω ^ b → a + ω ^ b ≤ ω ^ b
h : a < ω ^ succ b
⊢ a + ω ^ succ b ≤ ω ^ succ b

tactic: rcases(lt_mul_of_limit omega_isLimit).1 h with ⟨x, xo, ax⟩
state_before: case H₂
a b✝ : Ordinal
h✝ : a < ω ^ b✝
b : Ordinal
a✝ : a < ω ^ b → a + ω ^ b ≤ ω ^ b
h : a < ω ^ b * ω
⊢ a + ω ^ succ b ≤ ω ^ succ b

tactic: refine' le_trans (add_le_add_right (le_of_lt ax) _) _
state_before: case H₂.intro.intro
a b✝ : Ordinal
h✝ : a < ω ^ b✝
b : Ordinal
a✝ : a < ω ^ b → a + ω ^ b ≤ ω ^ b
h : a < ω ^ b * ω
x : Ordinal
xo : x < ω
ax : a < ω ^ b * x
⊢ a + ω ^ succ b ≤ ω ^ succ b

tactic: rw [opow_succ, ← mul_add, add_omega xo]
state_before: case H₂.intro.intro
a b✝ : Ordinal
h✝ : a < ω ^ b✝
b : Ordinal
a✝ : a < ω ^ b → a + ω ^ b ≤ ω ^ b
h : a < ω ^ b * ω
x : Ordinal
xo : x < ω
ax : a < ω ^ b * x
⊢ ω ^ b * x + ω ^ succ b ≤ ω ^ succ b

tactic: rcases(lt_opow_of_limit omega_ne_zero l).1 h with ⟨x, xb, ax⟩
state_before: case H₃
a b✝ : Ordinal
h✝ : a < ω ^ b✝
b : Ordinal
l : IsLimit b
IH : ∀ (o' : Ordinal), o' < b → a < ω ^ o' → a + ω ^ o' ≤ ω ^ o'
h : a < ω ^ b
⊢ a + ω ^ b ≤ ω ^ b

tactic: exact
  (((add_isNormal a).trans (opow_isNormal one_lt_omega)).limit_le l).2 fun y yb =>
    (add_le_add_left (opow_le_opow_right omega_pos (le_max_right _ _)) _).trans
      (le_trans
        (IH _ (max_lt xb yb) (ax.trans_le <| opow_le_opow_right omega_pos (le_max_left _ _)))
        (opow_le_opow_right omega_pos <| le_of_lt <| max_lt xb yb))
state_before: case H₃.intro.intro
a b✝ : Ordinal
h✝ : a < ω ^ b✝
b : Ordinal
l : IsLimit b
IH : ∀ (o' : Ordinal), o' < b → a < ω ^ o' → a + ω ^ o' ≤ ω ^ o'
h : a < ω ^ b
x : Ordinal
xb : x < b
ax : a < ω ^ x
⊢ a + ω ^ b ≤ ω ^ b
Theorem: IsLocalization.toInvSubmonoid_eq_mk'
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

tactic: rw [← (IsLocalization.map_units S x).mul_left_inj]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.210005
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : { x // x ∈ M }
⊢ ↑(↑(toInvSubmonoid M S) x) = mk' S 1 x

tactic: simp
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.210005
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : { x // x ∈ M }
⊢ ↑(↑(toInvSubmonoid M S) x) * ↑(algebraMap R S) ↑x = mk' S 1 x * ↑(algebraMap R S) ↑x
Theorem: Polynomial.trinomial_monic
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: nontriviality R
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
⊢ Monic (trinomial k m n u v 1)

tactic: exact trinomial_leadingCoeff hkm hmn one_ne_zero
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
✝ : Nontrivial R
⊢ Monic (trinomial k m n u v 1)
Theorem: MeasureTheory.ofReal_set_integral_one_of_measure_ne_top
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: simp only [norm_one]
state_before: α✝ : Type ?u.46613
β : Type ?u.46616
E : Type ?u.46619
F : Type ?u.46622
inst✝³ : MeasurableSpace α✝
inst✝² : NormedAddCommGroup E
f g : α✝ → E
s✝ t : Set α✝
μ✝ ν : Measure α✝
l l' : Filter α✝
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s : Set α
hs : ↑↑μ s ≠ ⊤
⊢ ENNReal.ofReal (∫ (x : α) in s, 1 ∂μ) = ENNReal.ofReal (∫ (x : α) in s, ‖1‖ ∂μ)

tactic: rw [ofReal_integral_norm_eq_lintegral_nnnorm (integrableOn_const.2 (Or.inr hs.lt_top))]
state_before: α✝ : Type ?u.46613
β : Type ?u.46616
E : Type ?u.46619
F : Type ?u.46622
inst✝³ : MeasurableSpace α✝
inst✝² : NormedAddCommGroup E
f g : α✝ → E
s✝ t : Set α✝
μ✝ ν : Measure α✝
l l' : Filter α✝
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s : Set α
hs : ↑↑μ s ≠ ⊤
⊢ ENNReal.ofReal (∫ (x : α) in s, ‖1‖ ∂μ) = ∫⁻ (x : α) in s, 1 ∂μ

tactic: simp only [nnnorm_one, ENNReal.coe_one]
state_before: α✝ : Type ?u.46613
β : Type ?u.46616
E : Type ?u.46619
F : Type ?u.46622
inst✝³ : MeasurableSpace α✝
inst✝² : NormedAddCommGroup E
f g : α✝ → E
s✝ t : Set α✝
μ✝ ν : Measure α✝
l l' : Filter α✝
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s : Set α
hs : ↑↑μ s ≠ ⊤
⊢ (∫⁻ (x : α) in s, ↑‖1‖₊ ∂μ) = ∫⁻ (x : α) in s, 1 ∂μ
Theorem: List.dropSlice_eq
File: Mathlib/Data/List/Basic.lean

tactic: induction n generalizing xs
state_before: ι : Type ?u.491870
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ xs : List α
n m : ℕ
⊢ dropSlice n m xs = take n xs ++ drop (n + m) xs

tactic: cases xs <;> simp [dropSlice]
state_before: case zero
ι : Type ?u.491870
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
m : ℕ
xs : List α
⊢ dropSlice zero m xs = take zero xs ++ drop (zero + m) xs

tactic: cases xs <;> simp [dropSlice, *, Nat.succ_add]
state_before: case succ
ι : Type ?u.491870
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
m n✝ : ℕ
n_ih✝ : ∀ (xs : List α), dropSlice n✝ m xs = take n✝ xs ++ drop (n✝ + m) xs
xs : List α
⊢ dropSlice (succ n✝) m xs = take (succ n✝) xs ++ drop (succ n✝ + m) xs
Theorem: Int.natAbs_even
File: Mathlib/Data/Int/Parity.lean

tactic: simp [even_iff_two_dvd, dvd_natAbs, coe_nat_dvd_left.symm]
state_before: m n : ℤ
⊢ Even (natAbs n) ↔ Even n
Theorem: Matrix.inv_mul_eq_iff_eq_mul_of_invertible
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← h, mul_inv_cancel_left_of_invertible]
state_before: l : Type ?u.232766
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A✝ B✝ A B C : Matrix n n α
inst✝ : Invertible A
h : A⁻¹ ⬝ B = C
⊢ B = A ⬝ C

tactic: rw [h, inv_mul_cancel_left_of_invertible]
state_before: l : Type ?u.232766
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A✝ B✝ A B C : Matrix n n α
inst✝ : Invertible A
h : B = A ⬝ C
⊢ A⁻¹ ⬝ B = C
Theorem: Sum.Not_isRight
File: Mathlib/Data/Sum/Basic.lean

tactic: simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.7847
δ : Type ?u.7850
x y : α ⊕ β
⊢ ¬isRight x = true ↔ isLeft x = true
Theorem: CategoryTheory.μ_naturalityᵣ
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← μ_naturality₂ F (𝟙 m) g X]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n n' : M
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (𝟙 m ⊗ g)).app X

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n n' : M
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n').app X =
    (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map (𝟙 m)).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n').app X
Theorem: guard_true
File: Mathlib/Control/Basic.lean

tactic: simp [guard, if_pos]
state_before: α β γ : Type u
F : Type → Type v
inst✝ : Alternative F
h : Decidable True
⊢ guard True = pure ()
Theorem: SimpleGraph.hasse_prod
File: Mathlib/Combinatorics/SimpleGraph/Hasse.lean

tactic: ext (x y)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
⊢ hasse (α × β) = hasse α □ hasse β

tactic: simp_rw [boxProd_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
  or_or_or_comm]
state_before: case Adj.h.h.a
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
x y : α × β
⊢ Adj (hasse (α × β)) x y ↔ Adj (hasse α □ hasse β) x y
Theorem: continuousAt_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: rw [continuousAt_congr (cpow_eq_nhds' hp_fst_ne_zero)]
state_before: α : Type ?u.293132
p : ℂ × ℂ
hp_fst : 0 < p.fst.re ∨ p.fst.im ≠ 0
hp_fst_ne_zero : p.fst ≠ 0
⊢ ContinuousAt (fun x => x.fst ^ x.snd) p

tactic: refine' continuous_exp.continuousAt.comp _
state_before: α : Type ?u.293132
p : ℂ × ℂ
hp_fst : 0 < p.fst.re ∨ p.fst.im ≠ 0
hp_fst_ne_zero : p.fst ≠ 0
⊢ ContinuousAt (fun x => Complex.exp (Complex.log x.fst * x.snd)) p

tactic: exact
  ContinuousAt.mul
    (ContinuousAt.comp (continuousAt_clog hp_fst) continuous_fst.continuousAt)
    continuous_snd.continuousAt
state_before: α : Type ?u.293132
p : ℂ × ℂ
hp_fst : 0 < p.fst.re ∨ p.fst.im ≠ 0
hp_fst_ne_zero : p.fst ≠ 0
⊢ ContinuousAt (fun x => Complex.log x.fst * x.snd) p

tactic: intro h
state_before: α : Type ?u.293132
p : ℂ × ℂ
hp_fst : 0 < p.fst.re ∨ p.fst.im ≠ 0
⊢ p.fst ≠ 0

tactic: rw [h] at hp_fst
state_before: case inr
α : Type ?u.293132
p : ℂ × ℂ
h : p.fst = 0
hp_fst : p.fst.im ≠ 0
⊢ False

tactic: simp at hp_fst
state_before: case inr
α : Type ?u.293132
p : ℂ × ℂ
h : p.fst = 0
hp_fst : 0.im ≠ 0
⊢ False
Theorem: Finset.max_singleton
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← insert_emptyc_eq]
state_before: F : Type ?u.312871
α : Type u_1
β : Type ?u.312877
γ : Type ?u.312880
ι : Type ?u.312883
κ : Type ?u.312886
inst✝ : LinearOrder α
a : α
⊢ Finset.max {a} = ↑a

tactic: exact max_insert
state_before: F : Type ?u.312871
α : Type u_1
β : Type ?u.312877
γ : Type ?u.312880
ι : Type ?u.312883
κ : Type ?u.312886
inst✝ : LinearOrder α
a : α
⊢ Finset.max (insert a ∅) = ↑a
Theorem: Polynomial.coeff_mul
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rcases p with ⟨p⟩
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
⊢ coeff (p * q) n = ∑ x in Nat.antidiagonal n, coeff p x.fst * coeff q x.snd

tactic: rcases q with ⟨q⟩
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r q : R[X]
n : ℕ
p : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := p } * q) n = ∑ x in Nat.antidiagonal n, coeff { toFinsupp := p } x.fst * coeff q x.snd

tactic: simp_rw [← ofFinsupp_mul, coeff]
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := p } * { toFinsupp := q }) n =
    ∑ x in Nat.antidiagonal n, coeff { toFinsupp := p } x.fst * coeff { toFinsupp := q } x.snd

tactic: exact AddMonoidAlgebra.mul_apply_antidiagonal p q n _ Nat.mem_antidiagonal
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : AddMonoidAlgebra R ℕ
⊢ ↑(p * q) n = ∑ x in Nat.antidiagonal n, ↑p x.fst * ↑q x.snd
Theorem: Function.Semiconj.bijOn_range
File: Mathlib/Data/Set/Function.lean

tactic: rw [← image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112998
ι : Sort ?u.113001
π : α → Type ?u.113006
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Bijective fa
hf : Injective f
⊢ BijOn fb (range f) (range f)

tactic: exact h.bijOn_image (bijective_iff_bijOn_univ.1 ha) (hf.injOn univ)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112998
ι : Sort ?u.113001
π : α → Type ?u.113006
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Bijective fa
hf : Injective f
⊢ BijOn fb (f '' univ) (f '' univ)
Theorem: Std.PairingHeapImp.Heap.WF.tail
File: Std/Data/PairingHeap.lean

tactic: simp only [Heap.tail]
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
hwf : WF le s
⊢ WF le (Heap.tail le s)

tactic: match eq : s.tail? le with
| none => exact Heap.WF.nil
| some tl => exact hwf.tail? eq
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
hwf : WF le s
⊢ WF le (Option.getD (Heap.tail? le s) Heap.nil)

tactic: exact Heap.WF.nil
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
hwf : WF le s
eq : Heap.tail? le s = none
⊢ WF le (Option.getD none Heap.nil)

tactic: exact hwf.tail? eq
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
hwf : WF le s
tl : Heap α
eq : Heap.tail? le s = some tl
⊢ WF le (Option.getD (some tl) Heap.nil)
Theorem: MonoidHom.mker_one
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: ext
state_before: M : Type u_1
N : Type u_2
P : Type ?u.140375
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.140396
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.140420
mc : MonoidHomClass F M N
⊢ mker 1 = ⊤

tactic: simp [mem_mker]
state_before: case h
M : Type u_1
N : Type u_2
P : Type ?u.140375
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.140396
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.140420
mc : MonoidHomClass F M N
x✝ : M
⊢ x✝ ∈ mker 1 ↔ x✝ ∈ ⊤
Theorem: OrderIso.isSimpleOrder_iff
File: Mathlib/Order/Atoms.lean

tactic: rw [isSimpleOrder_iff_isAtom_top, isSimpleOrder_iff_isAtom_top, ← f.isAtom_iff ⊤,
  f.map_top]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
⊢ IsSimpleOrder α ↔ IsSimpleOrder β
Theorem: orderOf_abs_ne_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf_eq_zero_iff']
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝ : LinearOrderedRing G
h : abs x ≠ 1
⊢ orderOf x = 0

tactic: intro n hn hx
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝ : LinearOrderedRing G
h : abs x ≠ 1
⊢ ∀ (n : ℕ), 0 < n → x ^ n ≠ 1

tactic: replace hx : |x| ^ n = 1 := by simpa only [abs_one, abs_pow] using congr_arg abs hx
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝ : LinearOrderedRing G
h : abs x ≠ 1
n : ℕ
hn : 0 < n
hx : x ^ n = 1
⊢ False

tactic: cases' h.lt_or_lt with h h
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝ : LinearOrderedRing G
h : abs x ≠ 1
n : ℕ
hn : 0 < n
hx : abs x ^ n = 1
⊢ False

tactic: simpa only [abs_one, abs_pow] using congr_arg abs hx
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝ : LinearOrderedRing G
h : abs x ≠ 1
n : ℕ
hn : 0 < n
hx : x ^ n = 1
⊢ abs x ^ n = 1

tactic: exact ((pow_lt_one (abs_nonneg x) h hn.ne').ne hx).elim
state_before: case inl
G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝ : LinearOrderedRing G
h✝ : abs x ≠ 1
n : ℕ
hn : 0 < n
hx : abs x ^ n = 1
h : abs x < 1
⊢ False

tactic: exact ((one_lt_pow h hn.ne').ne' hx).elim
state_before: case inr
G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝ : LinearOrderedRing G
h✝ : abs x ≠ 1
n : ℕ
hn : 0 < n
hx : abs x ^ n = 1
h : 1 < abs x
⊢ False
Theorem: Int.testBit_lxor
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_xor, testBit_bitwise]
state_before: m n : ℤ
k : ℕ
⊢ testBit (lxor' m n) k = xor (testBit m k) (testBit n k)
Theorem: TensorProduct.lift_mk_compr₂
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: rw [lift_compr₂ f, lift_mk, LinearMap.comp_id]
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.620874
inst✝¹³ : Monoid R'
R'' : Type ?u.620880
inst✝¹² : Semiring R''
M : Type u_3
N : Type u_2
P : Type u_4
Q : Type ?u.620895
S : Type ?u.620898
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
f✝ : M →ₗ[R] N →ₗ[R] P
f : M ⊗[R] N →ₗ[R] P
⊢ lift (LinearMap.compr₂ (mk R M N) f) = f
Theorem: InnerProductGeometry.inner_eq_neg_mul_norm_iff_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: refine' ⟨fun h => _, inner_eq_neg_mul_norm_of_angle_eq_pi⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ inner x y = -(‖x‖ * ‖y‖) ↔ angle x y = π

tactic: have h₁ : ‖x‖ * ‖y‖ ≠ 0 := (mul_pos (norm_pos_iff.mpr hx) (norm_pos_iff.mpr hy)).ne'
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : inner x y = -(‖x‖ * ‖y‖)
⊢ angle x y = π

tactic: rw [angle, h, neg_div, div_self h₁, Real.arccos_neg_one]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : inner x y = -(‖x‖ * ‖y‖)
h₁ : ‖x‖ * ‖y‖ ≠ 0
⊢ angle x y = π