tasksource/leandojo huggingface dataset:
Theorem: Equiv.Perm.isCycle_iff_exists_isCycleOn
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine' ⟨fun hf => ⟨{ x | f x ≠ x }, _, hf.isCycleOn, fun _ => id⟩, _⟩
state_before: ι : Type ?u.1652168
α : Type u_1
β : Type ?u.1652174
f g : Perm α
s t : Set α
a b x y : α
⊢ IsCycle f ↔ ∃ s, Set.Nontrivial s ∧ IsCycleOn f s ∧ ∀ ⦃x : α⦄, ¬IsFixedPt (↑f) x → x ∈ s

tactic: obtain ⟨a, ha⟩ := hf
state_before: case refine'_1
ι : Type ?u.1652168
α : Type u_1
β : Type ?u.1652174
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycle f
⊢ Set.Nontrivial {x | ↑f x ≠ x}

tactic: exact ⟨f a, f.injective.ne ha.1, a, ha.1, ha.1⟩
state_before: case refine'_1.intro
ι : Type ?u.1652168
α : Type u_1
β : Type ?u.1652174
f g : Perm α
s t : Set α
a✝ b x y a : α
ha : ↑f a ≠ a ∧ ∀ ⦃y : α⦄, ↑f y ≠ y → SameCycle f a y
⊢ Set.Nontrivial {x | ↑f x ≠ x}

tactic: rintro ⟨s, hs, hf, hsf⟩
state_before: case refine'_2
ι : Type ?u.1652168
α : Type u_1
β : Type ?u.1652174
f g : Perm α
s t : Set α
a b x y : α
⊢ (∃ s, Set.Nontrivial s ∧ IsCycleOn f s ∧ ∀ ⦃x : α⦄, ¬IsFixedPt (↑f) x → x ∈ s) → IsCycle f

tactic: obtain ⟨a, ha⟩ := hs.nonempty
state_before: case refine'_2.intro.intro.intro
ι : Type ?u.1652168
α : Type u_1
β : Type ?u.1652174
f g : Perm α
s✝ t : Set α
a b x y : α
s : Set α
hs : Set.Nontrivial s
hf : IsCycleOn f s
hsf : ∀ ⦃x : α⦄, ¬IsFixedPt (↑f) x → x ∈ s
⊢ IsCycle f

tactic: exact ⟨a, hf.apply_ne hs ha, fun b hb => hf.2 ha <| hsf hb⟩
state_before: case refine'_2.intro.intro.intro.intro
ι : Type ?u.1652168
α : Type u_1
β : Type ?u.1652174
f g : Perm α
s✝ t : Set α
a✝ b x y : α
s : Set α
hs : Set.Nontrivial s
hf : IsCycleOn f s
hsf : ∀ ⦃x : α⦄, ¬IsFixedPt (↑f) x → x ∈ s
a : α
ha : a ∈ s
⊢ IsCycle f
Theorem: not_differentiableAt_of_local_left_inverse_hasDerivAt_zero
File: Mathlib/Analysis/Calculus/Deriv/Inverse.lean

tactic: intro hg
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 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
⊢ ¬DifferentiableAt 𝕜 g a

tactic: have := (hf.comp a hg.hasDerivAt).congr_of_eventuallyEq hfg.symm
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 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
hg : DifferentiableAt 𝕜 g a
⊢ False

tactic: simpa using this.unique (hasDerivAt_id a)
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 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
hg : DifferentiableAt 𝕜 g a
this : HasDerivAt id (0 * deriv g a) a
⊢ False
Theorem: List.ofFn_const
File: Mathlib/Data/List/OfFn.lean

tactic: rw [replicate, ← ofFn_const n]
state_before: α : Type u
n : ℕ
c : α
⊢ (ofFn fun x => c) = replicate (n + 1) c

tactic: simp
state_before: α : Type u
n : ℕ
c : α
⊢ (ofFn fun x => c) = c :: ofFn fun x => c
Theorem: intervalIntegral.integral_symm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral, neg_sub]
state_before: ι : Type ?u.9818608
𝕜 : Type ?u.9818611
E : Type u_1
F : Type ?u.9818617
A : Type ?u.9818620
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b✝ : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
⊢ (∫ (x : ℝ) in b..a, f x ∂μ) = -∫ (x : ℝ) in a..b, f x ∂μ
Theorem: List.foldl_hom₂
File: Mathlib/Data/List/Basic.lean

tactic: revert a b
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : α → ι → α
op₂ : β → ι → β
op₃ : γ → ι → γ
a : α
b : β
h : ∀ (a : α) (b : β) (i : ι), f (op₁ a i) (op₂ b i) = op₃ (f a b) i
⊢ f (foldl op₁ a l) (foldl op₂ b l) = foldl op₃ (f a b) l

tactic: induction l <;> intros <;> [rfl; simp only [*, foldl]]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List ι
f : α → β → γ
op₁ : α → ι → α
op₂ : β → ι → β
op₃ : γ → ι → γ
h : ∀ (a : α) (b : β) (i : ι), f (op₁ a i) (op₂ b i) = op₃ (f a b) i
⊢ ∀ (a : α) (b : β), f (foldl op₁ a l) (foldl op₂ b l) = foldl op₃ (f a b) l
Theorem: div_zpow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_zpow, inv_zpow]
state_before: α : Type u_1
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✝ : DivisionCommMonoid α
a b : α
n : ℤ
⊢ (a / b) ^ n = a ^ n / b ^ n
Theorem: Complex.norm_deriv_le_of_forall_mem_sphere_norm_le
File: Mathlib/Analysis/Complex/Liouville.lean

tactic: set e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
c : ℂ
R C : ℝ
f : ℂ → F
hR : 0 < R
hd : DiffContOnCl ℂ f (ball c R)
hC : ∀ (z : ℂ), z ∈ sphere c R → ‖f z‖ ≤ C
⊢ ‖deriv f c‖ ≤ C / R

tactic: have : HasDerivAt (e ∘ f) (e (deriv f c)) c :=
  e.hasFDerivAt.comp_hasDerivAt c
    (hd.differentiableAt isOpen_ball <| mem_ball_self hR).hasDerivAt
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
c : ℂ
R C : ℝ
f : ℂ → F
hR : 0 < R
hd : DiffContOnCl ℂ f (ball c R)
hC : ∀ (z : ℂ), z ∈ sphere c R → ‖f z‖ ≤ C
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
⊢ ‖deriv f c‖ ≤ C / R

tactic: calc
  ‖deriv f c‖ = ‖deriv (e ∘ f) c‖ := by
    rw [this.deriv]
    exact (UniformSpace.Completion.norm_coe _).symm
  _ ≤ C / R :=
    norm_deriv_le_aux hR (e.differentiable.comp_diffContOnCl hd) fun z hz =>
      (UniformSpace.Completion.norm_coe _).trans_le (hC z hz)
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
c : ℂ
R C : ℝ
f : ℂ → F
hR : 0 < R
hd : DiffContOnCl ℂ f (ball c R)
hC : ∀ (z : ℂ), z ∈ sphere c R → ‖f z‖ ≤ C
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
this : HasDerivAt (↑e ∘ f) (↑e (deriv f c)) c
⊢ ‖deriv f c‖ ≤ C / R

tactic: rw [this.deriv]
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
c : ℂ
R C : ℝ
f : ℂ → F
hR : 0 < R
hd : DiffContOnCl ℂ f (ball c R)
hC : ∀ (z : ℂ), z ∈ sphere c R → ‖f z‖ ≤ C
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
this : HasDerivAt (↑e ∘ f) (↑e (deriv f c)) c
⊢ ‖deriv f c‖ = ‖deriv (↑e ∘ f) c‖

tactic: exact (UniformSpace.Completion.norm_coe _).symm
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
c : ℂ
R C : ℝ
f : ℂ → F
hR : 0 < R
hd : DiffContOnCl ℂ f (ball c R)
hC : ∀ (z : ℂ), z ∈ sphere c R → ‖f z‖ ≤ C
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
this : HasDerivAt (↑e ∘ f) (↑e (deriv f c)) c
⊢ ‖deriv f c‖ = ‖↑e (deriv f c)‖
Theorem: Finmap.keys_union
File: Mathlib/Data/Finmap.lean

tactic: simp [keys]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
⊢ ∀ (a : α), a ∈ keys (⟦s₁⟧ ∪ ⟦s₂⟧) ↔ a ∈ keys ⟦s₁⟧ ∪ keys ⟦s₂⟧
Theorem: Nat.ord_proj_pos
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: by_cases pp : p.Prime
state_before: n p : ℕ
⊢ 0 < p ^ ↑(factorization n) p

tactic: simp [pow_pos pp.pos]
state_before: case pos
n p : ℕ
pp : Prime p
⊢ 0 < p ^ ↑(factorization n) p

tactic: simp [pp]
state_before: case neg
n p : ℕ
pp : ¬Prime p
⊢ 0 < p ^ ↑(factorization n) p
Theorem: Polynomial.aeval_root_derivative_of_splits
File: Mathlib/Data/Polynomial/Splits.lean

tactic: replace hmo := hmo.map (algebraMap K L)
state_before: F : Type u
K : Type v
L : Type w
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Field F
i : K →+* L
inst✝ : Algebra K L
P : K[X]
hmo : Monic P
hP : Splits (algebraMap K L) P
r : L
hr : r ∈ roots (map (algebraMap K L) P)
⊢ ↑(aeval r) (↑derivative P) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase (roots (map (algebraMap K L) P)) r))

tactic: replace hP := (splits_id_iff_splits (algebraMap K L)).2 hP
state_before: F : Type u
K : Type v
L : Type w
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Field F
i : K →+* L
inst✝ : Algebra K L
P : K[X]
hP : Splits (algebraMap K L) P
r : L
hr : r ∈ roots (map (algebraMap K L) P)
hmo : Monic (map (algebraMap K L) P)
⊢ ↑(aeval r) (↑derivative P) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase (roots (map (algebraMap K L) P)) r))

tactic: rw [aeval_def, ← eval_map, ← derivative_map]
state_before: F : Type u
K : Type v
L : Type w
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Field F
i : K →+* L
inst✝ : Algebra K L
P : K[X]
r : L
hr : r ∈ roots (map (algebraMap K L) P)
hmo : Monic (map (algebraMap K L) P)
hP : Splits (RingHom.id L) (map (algebraMap K L) P)
⊢ ↑(aeval r) (↑derivative P) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase (roots (map (algebraMap K L) P)) r))

tactic: nth_rw 1 [eq_prod_roots_of_monic_of_splits_id hmo hP]
state_before: F : Type u
K : Type v
L : Type w
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Field F
i : K →+* L
inst✝ : Algebra K L
P : K[X]
r : L
hr : r ∈ roots (map (algebraMap K L) P)
hmo : Monic (map (algebraMap K L) P)
hP : Splits (RingHom.id L) (map (algebraMap K L) P)
⊢ eval r (↑derivative (map (algebraMap K L) P)) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase (roots (map (algebraMap K L) P)) r))

tactic: rw [eval_multiset_prod_X_sub_C_derivative hr]
state_before: F : Type u
K : Type v
L : Type w
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Field F
i : K →+* L
inst✝ : Algebra K L
P : K[X]
r : L
hr : r ∈ roots (map (algebraMap K L) P)
hmo : Monic (map (algebraMap K L) P)
hP : Splits (RingHom.id L) (map (algebraMap K L) P)
⊢ eval r (↑derivative (Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots (map (algebraMap K L) P))))) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase (roots (map (algebraMap K L) P)) r))
Theorem: List.foldrM_eq_foldr
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> simp [*]
state_before: ι : Type ?u.280076
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
m : Type v → Type w
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m β
b : β
l : List α
⊢ foldrM f b l = foldr (fun a mb => mb >>= f a) (pure b) l
Theorem: Set.pow_mem_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [pow_zero]
state_before: F : Type ?u.46143
α : Type u_1
β : Type ?u.46149
γ : Type ?u.46152
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
ha : a ∈ s
⊢ a ^ 0 ∈ s ^ 0

tactic: exact one_mem_one
state_before: F : Type ?u.46143
α : Type u_1
β : Type ?u.46149
γ : Type ?u.46152
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
ha : a ∈ s
⊢ 1 ∈ s ^ 0

tactic: rw [pow_succ]
state_before: F : Type ?u.46143
α : Type u_1
β : Type ?u.46149
γ : Type ?u.46152
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
ha : a ∈ s
n : ℕ
⊢ a ^ (n + 1) ∈ s ^ (n + 1)

tactic: exact mul_mem_mul ha (pow_mem_pow ha _)
state_before: F : Type ?u.46143
α : Type u_1
β : Type ?u.46149
γ : Type ?u.46152
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
ha : a ∈ s
n : ℕ
⊢ a * a ^ n ∈ s ^ (n + 1)
Theorem: Nat.card_fintypeIco
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Fintype.card_ofFinset, card_Ico]
state_before: a b c : ℕ
⊢ Fintype.card ↑(Set.Ico a b) = b - a
Theorem: Finset.card_eq_succ
File: Mathlib/Data/Finset/Card.lean

tactic: simp only [h, card_erase_of_mem has, add_tsub_cancel_right]
state_before: α : Type u_1
β : Type ?u.59235
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
h : card s = n + 1
a : α
has : a ∈ s
⊢ card (erase s a) = n
Theorem: Real.div_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [div_eq_mul_inv, mul_rpow hx (inv_nonneg.2 hy), inv_rpow hy]
state_before: x y z✝ : ℝ
hx : 0 ≤ x
hy : 0 ≤ y
z : ℝ
⊢ (x / y) ^ z = x ^ z / y ^ z
Theorem: CategoryTheory.Limits.inr_comp_pushoutSymmetry_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [Iso.comp_inv_eq]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ pushout.inr ≫ (pushoutSymmetry f g).inv = pushout.inl
Theorem: Cardinal.nat_coe_dvd_iff
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

tactic: refine' ⟨_, fun ⟨h, ht⟩ => ⟨h, by exact_mod_cast ht⟩⟩
state_before: a b : Cardinal
n m : ℕ
⊢ ↑n ∣ ↑m ↔ n ∣ m

tactic: rintro ⟨k, hk⟩
state_before: a b : Cardinal
n m : ℕ
⊢ ↑n ∣ ↑m → n ∣ m

tactic: have : ↑m < ℵ₀ := nat_lt_aleph0 m
state_before: case intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
⊢ n ∣ m

tactic: rw [hk, mul_lt_aleph0_iff] at this
state_before: case intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
this : ↑m < ℵ₀
⊢ n ∣ m

tactic: rcases this with (h | h | ⟨-, hk'⟩)
state_before: case intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
this : ↑n = 0 ∨ k = 0 ∨ ↑n < ℵ₀ ∧ k < ℵ₀
⊢ n ∣ m

tactic: iterate 2 simp only [h, mul_zero, zero_mul, Nat.cast_eq_zero] at hk; simp [hk]
state_before: case intro.inl
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
h : ↑n = 0
⊢ n ∣ m

case intro.inr.inl
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
h : k = 0
⊢ n ∣ m

case intro.inr.inr.intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
hk' : k < ℵ₀
⊢ n ∣ m

tactic: lift k to ℕ using hk'
state_before: case intro.inr.inr.intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
hk' : k < ℵ₀
⊢ n ∣ m

tactic: exact ⟨k, by exact_mod_cast hk⟩
state_before: case intro.inr.inr.intro.intro
a b : Cardinal
n m k : ℕ
hk : ↑m = ↑n * ↑k
⊢ n ∣ m

tactic: exact_mod_cast ht
state_before: a b : Cardinal
n m : ℕ
x✝ : n ∣ m
h : ℕ
ht : m = n * h
⊢ ↑m = ↑n * ↑h

tactic: simp only [h, mul_zero, zero_mul, Nat.cast_eq_zero] at hk
state_before: case intro.inr.inl
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
h : k = 0
⊢ n ∣ m

case intro.inr.inr.intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
hk' : k < ℵ₀
⊢ n ∣ m

tactic: simp [hk]
state_before: case intro.inr.inl
a b : Cardinal
n m : ℕ
k : Cardinal
h : k = 0
hk : m = 0
⊢ n ∣ m

case intro.inr.inr.intro
a b : Cardinal
n m : ℕ
k : Cardinal
hk : ↑m = ↑n * k
hk' : k < ℵ₀
⊢ n ∣ m

tactic: exact_mod_cast hk
state_before: a b : Cardinal
n m k : ℕ
hk : ↑m = ↑n * ↑k
⊢ m = n * k
Theorem: MeasureTheory.hasFiniteIntegral_smul_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: obtain ⟨c, rfl⟩ := hc
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.780865
δ : Type ?u.780868
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
hc : IsUnit c
f : α → β
⊢ HasFiniteIntegral (c • f) ↔ HasFiniteIntegral f

tactic: constructor
state_before: case intro
α : Type u_3
β : Type u_2
γ : Type ?u.780865
δ : Type ?u.780868
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral (↑c • f) ↔ HasFiniteIntegral f

tactic: exact HasFiniteIntegral.smul _
state_before: case intro.mpr
α : Type u_3
β : Type u_2
γ : Type ?u.780865
δ : Type ?u.780868
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral f → HasFiniteIntegral (↑c • f)

tactic: intro h
state_before: case intro.mp
α : Type u_3
β : Type u_2
γ : Type ?u.780865
δ : Type ?u.780868
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
⊢ HasFiniteIntegral (↑c • f) → HasFiniteIntegral f

tactic: simpa only [smul_smul, Units.inv_mul, one_smul] using h.smul ((c⁻¹ : 𝕜ˣ) : 𝕜)
state_before: case intro.mp
α : Type u_3
β : Type u_2
γ : Type ?u.780865
δ : Type ?u.780868
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : MulActionWithZero 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
c : 𝕜ˣ
h : HasFiniteIntegral (↑c • f)
⊢ HasFiniteIntegral f
Theorem: CategoryTheory.Injective.of_iso
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

tactic: obtain ⟨h, h_eq⟩ := @Injective.factors C _ P _ _ _ (g ≫ i.inv) f mono
state_before: C : Type u₁
inst✝ : Category C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
⊢ ∃ h, f ≫ h = g

tactic: refine' ⟨h ≫ i.hom, _⟩
state_before: case intro
C : Type u₁
inst✝ : Category C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
h : Y✝ ⟶ P
h_eq : f ≫ h = g ≫ i.inv
⊢ ∃ h, f ≫ h = g

tactic: rw [← Category.assoc, h_eq, Category.assoc, Iso.inv_hom_id, Category.comp_id]
state_before: case intro
C : Type u₁
inst✝ : Category C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
h : Y✝ ⟶ P
h_eq : f ≫ h = g ≫ i.inv
⊢ f ≫ h ≫ i.hom = g
Theorem: Ideal.finite_factors
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: rw [← Set.finite_coe_iff, Set.coe_setOf]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.2605
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite {v | v.asIdeal ∣ I}

tactic: haveI h_fin := fintypeSubtypeDvd I hI
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.2605
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Finite { x // x.asIdeal ∣ I }

tactic: refine'
  Finite.of_injective (fun v => (⟨(v : HeightOneSpectrum R).asIdeal, v.2⟩ : { x // x ∣ I })) _
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.2605
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
h_fin : Fintype { x // x ∣ I }
⊢ Finite { x // x.asIdeal ∣ I }

tactic: intro v w hvw
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.2605
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
h_fin : Fintype { x // x ∣ I }
⊢ Injective fun v => { val := (↑v).asIdeal, property := (_ : (↑v).asIdeal ∣ I) }

tactic: simp at hvw
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.2605
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
h_fin : Fintype { x // x ∣ I }
v w : { x // x.asIdeal ∣ I }
hvw :
  (fun v => { val := (↑v).asIdeal, property := (_ : (↑v).asIdeal ∣ I) }) v =
    (fun v => { val := (↑v).asIdeal, property := (_ : (↑v).asIdeal ∣ I) }) w
⊢ v = w

tactic: exact Subtype.coe_injective ((HeightOneSpectrum.ext_iff (R := R) ↑v ↑w).mpr hvw)
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.2605
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
h_fin : Fintype { x // x ∣ I }
v w : { x // x.asIdeal ∣ I }
hvw : (↑v).asIdeal = (↑w).asIdeal
⊢ v = w
Theorem: Set.isWf_insert
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp only [← singleton_union, isWf_union, isWf_singleton, true_and_iff]
state_before: ι : Type ?u.107703
α : Type u_1
β : Type ?u.107709
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a : α
⊢ IsWf (insert a s) ↔ IsWf s
Theorem: PiLp.iSup_edist_ne_top_aux
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: cases nonempty_fintype ι
state_before: p : ℝ≥0∞
𝕜 : Type ?u.36838
𝕜' : Type ?u.36841
ι✝ : Type ?u.36844
α✝ : ι✝ → Type ?u.36849
β : ι✝ → Type ?u.36854
inst✝⁵ : Fact (1 ≤ p)
inst✝⁴ : (i : ι✝) → PseudoMetricSpace (α✝ i)
inst✝³ : (i : ι✝) → PseudoEMetricSpace (β i)
inst✝² : Fintype ι✝
ι : Type u_1
inst✝¹ : Finite ι
α : ι → Type u_2
inst✝ : (i : ι) → PseudoMetricSpace (α i)
f g : PiLp ⊤ α
⊢ (⨆ (i : ι), edist (f i) (g i)) ≠ ⊤

tactic: obtain ⟨M, hM⟩ := Fintype.exists_le fun i => (⟨dist (f i) (g i), dist_nonneg⟩ : ℝ≥0)
state_before: case intro
p : ℝ≥0∞
𝕜 : Type ?u.36838
𝕜' : Type ?u.36841
ι✝ : Type ?u.36844
α✝ : ι✝ → Type ?u.36849
β : ι✝ → Type ?u.36854
inst✝⁵ : Fact (1 ≤ p)
inst✝⁴ : (i : ι✝) → PseudoMetricSpace (α✝ i)
inst✝³ : (i : ι✝) → PseudoEMetricSpace (β i)
inst✝² : Fintype ι✝
ι : Type u_1
inst✝¹ : Finite ι
α : ι → Type u_2
inst✝ : (i : ι) → PseudoMetricSpace (α i)
f g : PiLp ⊤ α
val✝ : Fintype ι
⊢ (⨆ (i : ι), edist (f i) (g i)) ≠ ⊤

tactic: refine' ne_of_lt ((iSup_le fun i => _).trans_lt (@ENNReal.coe_lt_top M))
state_before: case intro.intro
p : ℝ≥0∞
𝕜 : Type ?u.36838
𝕜' : Type ?u.36841
ι✝ : Type ?u.36844
α✝ : ι✝ → Type ?u.36849
β : ι✝ → Type ?u.36854
inst✝⁵ : Fact (1 ≤ p)
inst✝⁴ : (i : ι✝) → PseudoMetricSpace (α✝ i)
inst✝³ : (i : ι✝) → PseudoEMetricSpace (β i)
inst✝² : Fintype ι✝
ι : Type u_1
inst✝¹ : Finite ι
α : ι → Type u_2
inst✝ : (i : ι) → PseudoMetricSpace (α i)
f g : PiLp ⊤ α
val✝ : Fintype ι
M : { r // 0 ≤ r }
hM : ∀ (i : ι), { val := dist (f i) (g i), property := (_ : 0 ≤ dist (f i) (g i)) } ≤ M
⊢ (⨆ (i : ι), edist (f i) (g i)) ≠ ⊤

tactic: simp only [edist, PseudoMetricSpace.edist_dist, ENNReal.ofReal_eq_coe_nnreal dist_nonneg]
state_before: case intro.intro
p : ℝ≥0∞
𝕜 : Type ?u.36838
𝕜' : Type ?u.36841
ι✝ : Type ?u.36844
α✝ : ι✝ → Type ?u.36849
β : ι✝ → Type ?u.36854
inst✝⁵ : Fact (1 ≤ p)
inst✝⁴ : (i : ι✝) → PseudoMetricSpace (α✝ i)
inst✝³ : (i : ι✝) → PseudoEMetricSpace (β i)
inst✝² : Fintype ι✝
ι : Type u_1
inst✝¹ : Finite ι
α : ι → Type u_2
inst✝ : (i : ι) → PseudoMetricSpace (α i)
f g : PiLp ⊤ α
val✝ : Fintype ι
M : { r // 0 ≤ r }
hM : ∀ (i : ι), { val := dist (f i) (g i), property := (_ : 0 ≤ dist (f i) (g i)) } ≤ M
i : ι
⊢ edist (f i) (g i) ≤ ↑M

tactic: exact_mod_cast hM i
state_before: case intro.intro
p : ℝ≥0∞
𝕜 : Type ?u.36838
𝕜' : Type ?u.36841
ι✝ : Type ?u.36844
α✝ : ι✝ → Type ?u.36849
β : ι✝ → Type ?u.36854
inst✝⁵ : Fact (1 ≤ p)
inst✝⁴ : (i : ι✝) → PseudoMetricSpace (α✝ i)
inst✝³ : (i : ι✝) → PseudoEMetricSpace (β i)
inst✝² : Fintype ι✝
ι : Type u_1
inst✝¹ : Finite ι
α : ι → Type u_2
inst✝ : (i : ι) → PseudoMetricSpace (α i)
f g : PiLp ⊤ α
val✝ : Fintype ι
M : { r // 0 ≤ r }
hM : ∀ (i : ι), { val := dist (f i) (g i), property := (_ : 0 ≤ dist (f i) (g i)) } ≤ M
i : ι
⊢ ↑{ val := dist (f i) (g i), property := (_ : 0 ≤ dist (f i) (g i)) } ≤ ↑M
Theorem: Real.isBigO_one_exp_comp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp only [← exp_zero, isBigO_exp_comp_exp_comp, Pi.sub_def, zero_sub, isBoundedUnder_le_neg]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => 1) =O[l] fun x => exp (f x)) ↔ IsBoundedUnder (fun x x_1 => x ≥ x_1) l f
Theorem: Con.sInf_def
File: Mathlib/GroupTheory/Congruence.lean

tactic: ext
state_before: M : Type u_1
N : Type ?u.20259
P : Type ?u.20262
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ ↑(sInf S) = sInf (FunLike.coe '' S)

tactic: simp only [sInf_image, iInf_apply, iInf_Prop_eq]
state_before: case h.h.a
M : Type u_1
N : Type ?u.20259
P : Type ?u.20262
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝¹ x✝ : M
⊢ ↑(sInf S) x✝¹ x✝ ↔ sInf (FunLike.coe '' S) x✝¹ x✝

tactic: rfl
state_before: case h.h.a
M : Type u_1
N : Type ?u.20259
P : Type ?u.20262
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝¹ x✝ : M
⊢ ↑(sInf S) x✝¹ x✝ ↔ ∀ (i : Con M), i ∈ S → ↑i x✝¹ x✝