tasksource/leandojo huggingface dataset:
Theorem: List.toFinset_surj_on
File: Mathlib/Data/Finset/Basic.lean

tactic: rintro ⟨⟨l⟩, hl⟩ _
state_before: α : Type u_1
β : Type ?u.461724
γ : Type ?u.461727
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ Set.SurjOn toFinset {l | Nodup l} Set.univ

tactic: exact ⟨l, hl, (toFinset_eq hl).symm⟩
state_before: case mk.mk
α : Type u_1
β : Type ?u.461724
γ : Type ?u.461727
inst✝ : DecidableEq α
l✝ l' : List α
a : α
val✝ : Multiset α
l : List α
hl : Multiset.Nodup (Quot.mk Setoid.r l)
a✝ : { val := Quot.mk Setoid.r l, nodup := hl } ∈ Set.univ
⊢ { val := Quot.mk Setoid.r l, nodup := hl } ∈ toFinset '' {l | Nodup l}
Theorem: not_wcovby_iff
File: Mathlib/Order/Cover.lean

tactic: simp_rw [Wcovby, h, true_and_iff, not_forall, exists_prop, not_not]
state_before: α : Type u_1
β : Type ?u.9689
inst✝¹ : Preorder α
inst✝ : Preorder β
a b c : α
h : a ≤ b
⊢ ¬a ⩿ b ↔ ∃ c, a < c ∧ c < b
Theorem: Set.unbounded_lt_inter_not_lt
File: Mathlib/Order/Bounded.lean

tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Unbounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Unbounded (fun x x_1 => x < x_1) s

tactic: exact bounded_lt_inter_not_lt a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : SemilatticeSup α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | ¬b < a}) ↔ Bounded (fun x x_1 => x < x_1) s
Theorem: Real.tan_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [tan_periodic.eq, tan_zero]
state_before: ⊢ tan π = 0
Theorem: List.count_dedup
File: Mathlib/Data/List/Dedup.lean

tactic: simp_rw [count_eq_of_nodup <| nodup_dedup l, mem_dedup]
state_before: α : Type u
inst✝ : DecidableEq α
l : List α
a : α
⊢ count a (dedup l) = if a ∈ l then 1 else 0
Theorem: lineMap_slope_slope_sub_div_sub
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

tactic: field_simp [sub_ne_zero.2 h.symm, ← sub_div_sub_smul_slope_add_sub_div_sub_smul_slope f a b c,
  lineMap_apply_module]
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
h : a ≠ c
⊢ ↑(lineMap (slope f a b) (slope f b c)) ((c - b) / (c - a)) = slope f a c
Theorem: BooleanRing.inf_comm
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type ?u.13028
γ : Type ?u.13031
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : α
⊢ a * b = b * a
Theorem: MonoidHom.map_range
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [range_eq_map, range_eq_map]
state_before: G : Type u_3
G' : Type ?u.474061
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.474070
inst✝² : AddGroup A
N : Type u_1
P : Type u_2
inst✝¹ : Group N
inst✝ : Group P
K : Subgroup G
g : N →* P
f : G →* N
⊢ map g (range f) = range (comp g f)

tactic: exact (⊤ : Subgroup G).map_map g f
state_before: G : Type u_3
G' : Type ?u.474061
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.474070
inst✝² : AddGroup A
N : Type u_1
P : Type u_2
inst✝¹ : Group N
inst✝ : Group P
K : Subgroup G
g : N →* P
f : G →* N
⊢ map g (map f ⊤) = map (comp g f) ⊤
Theorem: List.map_eq_foldr
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> simp [*]
state_before: ι : Type ?u.129786
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
⊢ map f l = foldr (fun a bs => f a :: bs) [] l
Theorem: VitaliFamily.eventually_filterAt_subset_closedBall
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: simp only [v.eventually_filterAt_iff]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
ε : ℝ
hε : 0 < ε
⊢ ∀ᶠ (a : Set α) in filterAt v x, a ⊆ closedBall x ε

tactic: exact ⟨ε, hε, fun a _ ha' => ha'⟩
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
ε : ℝ
hε : 0 < ε
⊢ ∃ ε_1, ε_1 > 0 ∧ ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε_1 → a ⊆ closedBall x ε
Theorem: PowerSeries.coeff_sin_bit0
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: rw [sin, coeff_mk, if_pos (even_bit0 n)]
state_before: A : Type u_1
A' : Type ?u.351728
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ ↑(coeff A (bit0 n)) (sin A) = 0
Theorem: multiplicity.unique'
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← PartENat.natCast_inj, PartENat.natCast_get, unique hk hsucc]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
hk : a ^ k ∣ b
hsucc : ¬a ^ (k + 1) ∣ b
⊢ k = Part.get (multiplicity a b) (_ : ∃ n, (fun n => ¬a ^ (n + 1) ∣ b) n)
Theorem: Filter.inducing_nhds
File: Mathlib/Topology/Filter.lean

tactic: simp (config := { contextual := true }) only [nhds_nhds, comap_iInf, comap_principal,
  Iic_principal, preimage_setOf_eq, ← mem_interior_iff_mem_nhds, setOf_mem_eq,
  IsOpen.interior_eq]
state_before: ι : Sort ?u.23236
α : Type ?u.23239
β : Type ?u.23242
X : Type u_1
Y : Type ?u.23248
inst✝ : TopologicalSpace X
x : X
⊢ (⨅ (s : Set X) (_ : IsOpen s) (_ : x ∈ s), 𝓟 s) = comap 𝓝 (𝓝 (𝓝 x))
Theorem: eq_of_fderiv_eq
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa using hf' _
state_before: E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.262038
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_1
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C : ℝ
s : Set E
x✝² y : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
hf : Differentiable 𝕜 f
hg : Differentiable 𝕜 g
hf' : ∀ (x : E), fderiv 𝕜 f x = fderiv 𝕜 g x
x✝¹ : E
hfgx : f x✝¹ = g x✝¹
x : E
x✝ : x ∈ univ
⊢ fderivWithin 𝕜 f univ x = fderivWithin 𝕜 g univ x
Theorem: Set.ncard_inter_add_ncard_diff_eq_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: simp_rw [← ncard_diff_add_ncard_eq_ncard (diff_subset s t) hs, sdiff_sdiff_right_self,
  inf_eq_inter]
state_before: α : Type u_1
β : Type ?u.128103
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (s ∩ t) + ncard (s \ t) = ncard s
Theorem: ProbabilityTheory.kernel.set_lintegral_restrict
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [restrict_apply, Measure.restrict_restrict' hs]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1445604
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
s t✝ : Set β
κ : { x // x ∈ kernel α β }
hs : MeasurableSet s
a : α
f : β → ℝ≥0∞
t : Set β
⊢ (∫⁻ (b : β) in t, f b ∂↑(kernel.restrict κ hs) a) = ∫⁻ (b : β) in t ∩ s, f b ∂↑κ a
Theorem: Finset.sum_card
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: simp_rw [Fintype.card, ← sum_card_inter fun a _ ↦ h a, univ_inter]
state_before: ι : Type ?u.111164
α : Type u_1
β : Type ?u.111170
M : Type ?u.111173
N : Type ?u.111176
G : Type ?u.111179
k : Type ?u.111182
R : Type ?u.111185
inst✝¹ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
inst✝ : Fintype α
h : ∀ (a : α), card (filter ((fun x x_1 => x ∈ x_1) a) B) = n
⊢ ∑ s in B, card s = Fintype.card α * n
Theorem: Finset.image₂_inter_singleton
File: Mathlib/Data/Finset/NAry.lean

tactic: simp_rw [image₂_singleton_right, image_inter _ _ hf]
state_before: α : Type u_1
α' : Type ?u.53422
β : Type u_3
β' : Type ?u.53428
γ : Type u_2
γ' : Type ?u.53434
δ : Type ?u.53437
δ' : Type ?u.53440
ε : Type ?u.53443
ε' : Type ?u.53446
ζ : Type ?u.53449
ζ' : Type ?u.53452
ν : Type ?u.53455
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq α
s₁ s₂ : Finset α
hf : Injective fun a => f a b
⊢ image₂ f (s₁ ∩ s₂) {b} = image₂ f s₁ {b} ∩ image₂ f s₂ {b}
Theorem: Part.fix_def'
File: Mathlib/Control/Fix.lean

tactic: dsimp [Part.fix]
state_before: α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ Part.fix f x = none

tactic: rw [assert_neg h']
state_before: α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ (assert (∃ i, (Fix.approx f i x).Dom) fun h =>
      WellFounded.fix (_ : WellFounded (Upto.GT fun x_1 => (Fix.approx f x_1 x).Dom)) (fixAux f) Upto.zero x) =
    none
Theorem: Inducing.inducing_iff
File: Mathlib/Topology/Maps.lean

tactic: refine' ⟨fun h => hg.comp h, fun hgf => inducing_of_inducing_compose _ hg.continuous hgf⟩
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.5084
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
⊢ Inducing f ↔ Inducing (g ∘ f)

tactic: rw [hg.continuous_iff]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.5084
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
hgf : Inducing (g ∘ f)
⊢ Continuous f

tactic: exact hgf.continuous
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.5084
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
hgf : Inducing (g ∘ f)
⊢ Continuous (g ∘ f)
Theorem: Complex.arg_eq_nhds_of_re_neg_of_im_neg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: suffices h_forall_nhds : ∀ᶠ y : ℂ in 𝓝 x, y.re < 0 ∧ y.im < 0
state_before: x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ arg =ᶠ[𝓝 x] fun x => arcsin ((-x).im / ↑abs x) - π

tactic: exact h_forall_nhds.mono fun y hy => arg_of_re_neg_of_im_neg hy.1 hy.2
state_before: x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
h_forall_nhds : ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ y.im < 0
⊢ arg =ᶠ[𝓝 x] fun x => arcsin ((-x).im / ↑abs x) - π

case h_forall_nhds
x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ y.im < 0

tactic: refine' IsOpen.eventually_mem _ (⟨hx_re, hx_im⟩ : x.re < 0 ∧ x.im < 0)
state_before: case h_forall_nhds
x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ y.im < 0

tactic: exact
  IsOpen.and (isOpen_lt continuous_re continuous_zero) (isOpen_lt continuous_im continuous_zero)
state_before: case h_forall_nhds
x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ IsOpen fun y => y.re < 0 ∧ y.im < 0
Theorem: Function.Injective.sameRay_map_iff
File: Mathlib/LinearAlgebra/Ray.lean

tactic: simp only [SameRay, map_zero, ← hf.eq_iff, map_smul]
state_before: R : Type u_2
inst✝⁶ : StrictOrderedCommSemiring R
M : Type u_3
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
N : Type u_4
inst✝³ : AddCommMonoid N
inst✝² : Module R N
ι : Type ?u.44462
inst✝¹ : DecidableEq ι
x y z : M
F : Type u_1
inst✝ : LinearMapClass F R M N
f : F
hf : Function.Injective ↑f
⊢ SameRay R (↑f x) (↑f y) ↔ SameRay R x y
Theorem: MvPolynomial.support_X_pow
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: classical
  rw [X_pow_eq_monomial, support_monomial, if_neg (one_ne_zero' R)]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
s : σ
n : ℕ
⊢ support (X s ^ n) = {Finsupp.single s n}

tactic: rw [X_pow_eq_monomial, support_monomial, if_neg (one_ne_zero' R)]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
s : σ
n : ℕ
⊢ support (X s ^ n) = {Finsupp.single s n}
Theorem: Set.ite_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp [Set.ite]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ Set.ite s t s = t ∩ s
Theorem: Finset.exists_le_of_prod_le'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: contrapose! Hle with Hlt
state_before: ι : Type u_1
α : Type ?u.144180
β : Type ?u.144183
M : Type u_2
N : Type ?u.144189
G : Type ?u.144192
k : Type ?u.144195
R : Type ?u.144198
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : Finset.Nonempty s
Hle : ∏ i in s, f i ≤ ∏ i in s, g i
⊢ ∃ i, i ∈ s ∧ f i ≤ g i

tactic: exact prod_lt_prod_of_nonempty' hs Hlt
state_before: ι : Type u_1
α : Type ?u.144180
β : Type ?u.144183
M : Type u_2
N : Type ?u.144189
G : Type ?u.144192
k : Type ?u.144195
R : Type ?u.144198
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : Finset.Nonempty s
Hlt : ∀ (i : ι), i ∈ s → g i < f i
⊢ ∏ i in s, g i < ∏ i in s, f i
Theorem: Subgroup.eq_top_of_card_eq
File: Mathlib/GroupTheory/Subgroup/Finite.lean

tactic: letI : Fintype (H : Set G) := ‹Fintype H›
state_before: G : Type u_1
inst✝³ : Group G
A : Type ?u.12172
inst✝² : AddGroup A
H K : Subgroup G
inst✝¹ : Fintype { x // x ∈ H }
inst✝ : Fintype G
h : Fintype.card { x // x ∈ H } = Fintype.card G
⊢ H = ⊤

tactic: rw [SetLike.ext'_iff, coe_top, ← Finset.coe_univ, ← (H : Set G).coe_toFinset, Finset.coe_inj, ←
  Finset.card_eq_iff_eq_univ, ← h, Set.toFinset_card]
state_before: G : Type u_1
inst✝³ : Group G
A : Type ?u.12172
inst✝² : AddGroup A
H K : Subgroup G
inst✝¹ : Fintype { x // x ∈ H }
inst✝ : Fintype G
h : Fintype.card { x // x ∈ H } = Fintype.card G
this : Fintype ↑↑H := inst✝¹
⊢ H = ⊤

tactic: congr
state_before: G : Type u_1
inst✝³ : Group G
A : Type ?u.12172
inst✝² : AddGroup A
H K : Subgroup G
inst✝¹ : Fintype { x // x ∈ H }
inst✝ : Fintype G
h : Fintype.card { x // x ∈ H } = Fintype.card G
this : Fintype ↑↑H := inst✝¹
⊢ Fintype.card ↑↑H = Fintype.card { x // x ∈ H }
Theorem: Option.liftOrGet_none_right
File: Std/Data/Option/Lemmas.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
f : α → α → α
a : Option α
⊢ liftOrGet f a none = a
Theorem: Polynomial.leadingCoeff_cubic
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [add_assoc, add_assoc, ← add_assoc (C b * X ^ 2), add_comm,
  leadingCoeff_add_of_degree_lt <| degree_quadratic_lt_degree_C_mul_X_cb ha,
  leadingCoeff_C_mul_X_pow]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.1557193
ha : a ≠ 0
⊢ leadingCoeff (↑C a * X ^ 3 + ↑C b * X ^ 2 + ↑C c * X + ↑C d) = a
Theorem: ZMod.coe_mul_inv_eq_one
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [Nat.coprime, Nat.gcd_comm, Nat.gcd_rec] at h
state_before: n x : ℕ
h : Nat.coprime x n
⊢ ↑x * (↑x)⁻¹ = 1

tactic: rw [mul_inv_eq_gcd, val_nat_cast, h, Nat.cast_one]
state_before: n x : ℕ
h : Nat.gcd (x % n) n = 1
⊢ ↑x * (↑x)⁻¹ = 1
Theorem: Nat.totient_eq_iff_prime
File: Mathlib/Data/Nat/Totient.lean

tactic: refine' ⟨fun h => _, totient_prime⟩
state_before: p : ℕ
hp : 0 < p
⊢ φ p = p - 1 ↔ Prime p

tactic: replace hp : 1 < p
state_before: p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ Prime p

tactic: rw [totient_eq_card_coprime, range_eq_Ico, ← Ico_insert_succ_left hp.le, Finset.filter_insert,
  if_neg (not_coprime_of_dvd_of_dvd hp (dvd_refl p) (dvd_zero p)), ← Nat.card_Ico 1 p] at h
state_before: p : ℕ
h : φ p = p - 1
hp : 1 < p
⊢ Prime p

tactic: refine'
  p.prime_of_coprime hp fun n hn hnz => Finset.filter_card_eq h n <| Finset.mem_Ico.mpr ⟨_, hn⟩
state_before: p : ℕ
h : Finset.card (filter (coprime p) (Ico (succ 0) p)) = Finset.card (Ico 1 p)
hp : 1 < p
⊢ Prime p

tactic: rwa [succ_le_iff, pos_iff_ne_zero]
state_before: p : ℕ
h : Finset.card (filter (coprime p) (Ico (succ 0) p)) = Finset.card (Ico 1 p)
hp : 1 < p
n : ℕ
hn : n < p
hnz : n ≠ 0
⊢ succ 0 ≤ n

tactic: apply lt_of_le_of_ne
state_before: case hp
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 < p

tactic: rwa [succ_le_iff]
state_before: case hp.a
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 ≤ p

tactic: rintro rfl
state_before: case hp.a
p : ℕ
hp : 0 < p
h : φ p = p - 1
⊢ 1 ≠ p

tactic: rw [totient_one, tsub_self] at h
state_before: case hp.a
hp : 0 < 1
h : φ 1 = 1 - 1
⊢ False

tactic: exact one_ne_zero h
state_before: case hp.a
hp : 0 < 1
h✝ : 1 = 1 - 1
h : 1 = 0
⊢ False
Theorem: MeasureTheory.Memℒp.sub
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [sub_eq_add_neg]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.5041387
G : Type ?u.5041390
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p
hg : Memℒp g p
⊢ Memℒp (f - g) p

tactic: exact hf.add hg.neg
state_before: α : Type u_2
E : Type u_1
F : Type ?u.5041387
G : Type ?u.5041390
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p
hg : Memℒp g p
⊢ Memℒp (f + -g) p
Theorem: HasDerivAt.pow
File: Mathlib/Analysis/Calculus/Deriv/Pow.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
hc : HasDerivAt c c' x
⊢ HasDerivAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') x

tactic: exact hc.pow n
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
hc : HasDerivWithinAt c c' univ x
⊢ HasDerivWithinAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') univ x
Theorem: UniformSpace.comap_quotient_le_uniformity
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: simp only [Prod.ext_iff, Quotient.eq] at h
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x y : α
x✝ :
  (x, y) ∈
    (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹'
      ((fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) '' id U)
x' y' : α
hx' : (x', y') ∈ id U
h :
  (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (x', y') =
    (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (x, y)
⊢ (x, y) ∈ id U

tactic: exact (((separationRel_iff_inseparable.1 h.1).prod
  (separationRel_iff_inseparable.1 h.2)).mem_open_iff hU.2).1 hx'
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x y : α
x✝ :
  (x, y) ∈
    (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹'
      ((fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) '' id U)
x' y' : α
hx' : (x', y') ∈ id U
h : x' ≈ x ∧ y' ≈ y
⊢ (x, y) ∈ id U
Theorem: MultilinearMap.alternatization_apply
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: simp only [alternatization_def, smul_apply, sum_apply]
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type ?u.689410
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type ?u.689440
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type ?u.689470
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_3
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_4
ι' : Type ?u.690249
ι'' : Type ?u.690252
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
⊢ ↑(↑alternatization m) v = ∑ σ : Perm ι, ↑Perm.sign σ • ↑(domDomCongr σ m) v
Theorem: Set.ncard_eq_toFinset_card'
File: Mathlib/Data/Set/Ncard.lean

tactic: simp [ncard_def, Nat.card_eq_fintype_card]
state_before: α : Type u_1
β : Type ?u.2524
s✝ t : Set α
a b x y : α
f : α → β
s : Set α
inst✝ : Fintype ↑s
⊢ ncard s = Finset.card (toFinset s)
Theorem: Embedding.prod_map
File: Mathlib/Topology/Constructions.lean

tactic: simp [hf.inj.eq_iff, hg.inj.eq_iff]
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type u_2
ε : Type ?u.67982
ζ : Type ?u.67985
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β
g : γ → δ
hf : _root_.Embedding f
hg : _root_.Embedding g
src✝ : Inducing (Prod.map f g) := Inducing.prod_map hf.toInducing hg.toInducing
x✝¹ x✝ : α × γ
x₁ : α
x₂ : γ
y₁ : α
y₂ : γ
⊢ Prod.map f g (x₁, x₂) = Prod.map f g (y₁, y₂) → (x₁, x₂) = (y₁, y₂)
Theorem: CategoryTheory.Injective.injective_of_adjoint
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
L : C ⥤ D
R : D ⥤ C
inst✝¹ : PreservesMonomorphisms L
adj : L ⊣ R
J : D
inst✝ : Injective J
A x✝ : C
g : A ⟶ R.obj J
f : A ⟶ x✝
im : Mono f
⊢ ↑(Adjunction.homEquiv adj A J).symm
      (f ≫ ↑(Adjunction.homEquiv adj x✝ J) (factorThru (↑(Adjunction.homEquiv adj A J).symm g) (L.map f))) =
    ↑(Adjunction.homEquiv adj A J).symm g
Theorem: Polynomial.natDegree_lt_natDegree_iff
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: intro h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.469198
hp : p ≠ 0
⊢ degree p < degree q → natDegree p < natDegree q

tactic: have hq : q ≠ 0 := ne_zero_of_degree_gt h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.469198
hp : p ≠ 0
h : degree p < degree q
⊢ natDegree p < natDegree q

tactic: rw [degree_eq_natDegree hp, degree_eq_natDegree hq, Nat.cast_withBot, Nat.cast_withBot] at h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.469198
hp : p ≠ 0
h : degree p < degree q
hq : q ≠ 0
⊢ natDegree p < natDegree q

tactic: exact_mod_cast h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.469198
hp : p ≠ 0
h : ↑(natDegree p) < ↑(natDegree q)
hq : q ≠ 0
⊢ natDegree p < natDegree q
Theorem: VitaliFamily.aemeasurable_limRatio
File: Mathlib/MeasureTheory/Covering/Differentiation.lean

tactic: apply ENNReal.aemeasurable_of_exist_almost_disjoint_supersets _ _ fun p q hpq => ?_
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
E : Type ?u.2775341
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : MeasureTheory.Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
⊢ AEMeasurable (limRatio v ρ)

tactic: exact v.exists_measurable_supersets_limRatio hρ hpq
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
E : Type ?u.2775341
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : MeasureTheory.Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
p q : ℝ≥0
hpq : p < q
⊢ ∃ u v_1,
    MeasurableSet u ∧
      MeasurableSet v_1 ∧ {x | limRatio v ρ x < ↑p} ⊆ u ∧ {x | ↑q < limRatio v ρ x} ⊆ v_1 ∧ ↑↑μ (u ∩ v_1) = 0
Theorem: finprod_mem_div_distrib
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp only [div_eq_mul_inv, finprod_mem_mul_distrib hs, finprod_mem_inv_distrib g hs]
state_before: α : Type u_2
β : Type ?u.322592
ι : Type ?u.322595
G : Type u_1
M : Type ?u.322601
N : Type ?u.322604
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
inst✝ : DivisionCommMonoid G
f g : α → G
hs : Set.Finite s
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i / g i) = (∏ᶠ (i : α) (_ : i ∈ s), f i) / ∏ᶠ (i : α) (_ : i ∈ s), g i
Theorem: Complex.cos_sub_sin_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [neg_mul, ← cosh_sub_sinh, sinh_mul_I, cosh_mul_I]
state_before: x y : ℂ
⊢ cos x - sin x * I = exp (-x * I)