tasksource/leandojo huggingface dataset:
Theorem: HasDerivWithinAt.clog
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

tactic: rw [div_eq_inv_mul]
state_before: α : Type ?u.48747
inst✝² : TopologicalSpace α
E : Type ?u.48753
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
s : Set ℂ
h₁ : HasDerivWithinAt f f' s x
h₂ : 0 < (f x).re ∨ (f x).im ≠ 0
⊢ HasDerivWithinAt (fun t => log (f t)) (f' / f x) s x

tactic: exact (hasStrictDerivAt_log h₂).hasDerivAt.comp_hasDerivWithinAt x h₁
state_before: α : Type ?u.48747
inst✝² : TopologicalSpace α
E : Type ?u.48753
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
s : Set ℂ
h₁ : HasDerivWithinAt f f' s x
h₂ : 0 < (f x).re ∨ (f x).im ≠ 0
⊢ HasDerivWithinAt (fun t => log (f t)) ((f x)⁻¹ * f') s x
Theorem: SemilatticeSup.ext
File: Mathlib/Order/Lattice.lean

tactic: have ss : A.toSup = B.toSup := by ext; apply SemilatticeSup.ext_sup H
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeSup α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ A = B

tactic: cases A
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeSup α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toSup = toSup
⊢ A = B

tactic: cases B
state_before: case mk
α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
B : SemilatticeSup α
toSup✝ : Sup α
toPartialOrder✝ : PartialOrder α
le_sup_left✝ : ∀ (a b : α), a ≤ a ⊔ b
le_sup_right✝ : ∀ (a b : α), b ≤ a ⊔ b
sup_le✝ : ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toSup = toSup
⊢ mk le_sup_left✝ le_sup_right✝ sup_le✝ = B

tactic: cases PartialOrder.ext H
state_before: case mk.mk
α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
toSup✝¹ : Sup α
toPartialOrder✝¹ : PartialOrder α
le_sup_left✝¹ : ∀ (a b : α), a ≤ a ⊔ b
le_sup_right✝¹ : ∀ (a b : α), b ≤ a ⊔ b
sup_le✝¹ : ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c
toSup✝ : Sup α
toPartialOrder✝ : PartialOrder α
le_sup_left✝ : ∀ (a b : α), a ≤ a ⊔ b
le_sup_right✝ : ∀ (a b : α), b ≤ a ⊔ b
sup_le✝ : ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toSup = toSup
⊢ mk le_sup_left✝¹ le_sup_right✝¹ sup_le✝¹ = mk le_sup_left✝ le_sup_right✝ sup_le✝

tactic: congr
state_before: case mk.mk.refl
α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
toSup✝¹ : Sup α
toPartialOrder✝ : PartialOrder α
le_sup_left✝¹ : ∀ (a b : α), a ≤ a ⊔ b
le_sup_right✝¹ : ∀ (a b : α), b ≤ a ⊔ b
sup_le✝¹ : ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c
toSup✝ : Sup α
le_sup_left✝ : ∀ (a b : α), a ≤ a ⊔ b
le_sup_right✝ : ∀ (a b : α), b ≤ a ⊔ b
sup_le✝ : ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toSup = toSup
⊢ mk le_sup_left✝¹ le_sup_right✝¹ sup_le✝¹ = mk le_sup_left✝ le_sup_right✝ sup_le✝

tactic: ext
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeSup α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ toSup = toSup

tactic: apply SemilatticeSup.ext_sup H
state_before: case sup.h.h
α✝ : Type u
β : Type v
inst✝ : SemilatticeSup α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeSup α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x✝¹ x✝ : α
⊢ x✝¹ ⊔ x✝ = x✝¹ ⊔ x✝
Theorem: PrimeSpectrum.isTopologicalBasis_basic_opens
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: apply TopologicalSpace.isTopologicalBasis_of_open_of_nhds
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ TopologicalSpace.IsTopologicalBasis (Set.range fun r => ↑(basicOpen r))

tactic: rintro _ ⟨r, rfl⟩
state_before: case h_open
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ∀ (u : Set (PrimeSpectrum R)), (u ∈ Set.range fun r => ↑(basicOpen r)) → IsOpen u

tactic: exact isOpen_basicOpen
state_before: case h_open.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
⊢ IsOpen ((fun r => ↑(basicOpen r)) r)

tactic: rintro p U hp ⟨s, hs⟩
state_before: case h_nhds
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ ∀ (a : PrimeSpectrum R) (u : Set (PrimeSpectrum R)),
    a ∈ u → IsOpen u → ∃ v, (v ∈ Set.range fun r => ↑(basicOpen r)) ∧ a ∈ v ∧ v ⊆ u

tactic: rw [← compl_compl U, Set.mem_compl_iff, ← hs, mem_zeroLocus, Set.not_subset] at hp
state_before: case h_nhds.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
p : PrimeSpectrum R
U : Set (PrimeSpectrum R)
hp : p ∈ U
s : Set R
hs : zeroLocus s = Uᶜ
⊢ ∃ v, (v ∈ Set.range fun r => ↑(basicOpen r)) ∧ p ∈ v ∧ v ⊆ U

tactic: obtain ⟨f, hfs, hfp⟩ := hp
state_before: case h_nhds.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
p : PrimeSpectrum R
U : Set (PrimeSpectrum R)
s : Set R
hp : ∃ a, a ∈ s ∧ ¬a ∈ ↑p.asIdeal
hs : zeroLocus s = Uᶜ
⊢ ∃ v, (v ∈ Set.range fun r => ↑(basicOpen r)) ∧ p ∈ v ∧ v ⊆ U

tactic: refine' ⟨basicOpen f, ⟨f, rfl⟩, hfp, _⟩
state_before: case h_nhds.intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
p : PrimeSpectrum R
U : Set (PrimeSpectrum R)
s : Set R
hs : zeroLocus s = Uᶜ
f : R
hfs : f ∈ s
hfp : ¬f ∈ ↑p.asIdeal
⊢ ∃ v, (v ∈ Set.range fun r => ↑(basicOpen r)) ∧ p ∈ v ∧ v ⊆ U

tactic: rw [← Set.compl_subset_compl, ← hs, basicOpen_eq_zeroLocus_compl, compl_compl]
state_before: case h_nhds.intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
p : PrimeSpectrum R
U : Set (PrimeSpectrum R)
s : Set R
hs : zeroLocus s = Uᶜ
f : R
hfs : f ∈ s
hfp : ¬f ∈ ↑p.asIdeal
⊢ ↑(basicOpen f) ⊆ U

tactic: exact zeroLocus_anti_mono (Set.singleton_subset_iff.mpr hfs)
state_before: case h_nhds.intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
p : PrimeSpectrum R
U : Set (PrimeSpectrum R)
s : Set R
hs : zeroLocus s = Uᶜ
f : R
hfs : f ∈ s
hfp : ¬f ∈ ↑p.asIdeal
⊢ zeroLocus s ⊆ zeroLocus {f}
Theorem: Polynomial.natTrailingDegree_monomial
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: rw [natTrailingDegree, trailingDegree_monomial ha]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ natTrailingDegree (↑(monomial n) a) = n

tactic: rfl
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ Option.getD (↑n) 0 = n
Theorem: MultilinearMap.cons_add
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simp_rw [← update_cons_zero x m (x + y), f.map_add, update_cons_zero]
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
f : MultilinearMap R M M₂
m : (i : Fin n) → M (succ i)
x y : M 0
⊢ ↑f (cons (x + y) m) = ↑f (cons x m) + ↑f (cons y m)
Theorem: Fin.contractNth_apply_of_eq
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: have : ¬(k : ℕ) < j := not_lt.2 (le_of_eq h.symm)
state_before: m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
h : ↑k = ↑j
⊢ contractNth j op g k = op (g (↑castSucc k)) (g (succ k))

tactic: rw [contractNth, if_neg this, if_pos h]
state_before: m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
h : ↑k = ↑j
this : ¬↑k < ↑j
⊢ contractNth j op g k = op (g (↑castSucc k)) (g (succ k))
Theorem: Finset.prod_eq_single
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rintro rfl
state_before: ι : Type ?u.372604
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
h₀ : ∀ (b : α), b ∈ s → b ≠ a → f b = 1
h₁ : ¬a ∈ s → f a = 1
this✝ : DecidableEq α
this : ¬a ∈ s
b : α
hb : b ∈ s
⊢ b ≠ a

tactic: exact this hb
state_before: ι : Type ?u.372604
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
this✝ : DecidableEq α
b : α
hb : b ∈ s
h₀ : ∀ (b_1 : α), b_1 ∈ s → b_1 ≠ b → f b_1 = 1
h₁ : ¬b ∈ s → f b = 1
this : ¬b ∈ s
⊢ False
Theorem: MvPolynomial.coeff_X
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: classical rw [coeff_X', if_pos rfl]
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
i : σ
⊢ coeff (Finsupp.single i 1) (X i) = 1

tactic: rw [coeff_X', if_pos rfl]
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
i : σ
⊢ coeff (Finsupp.single i 1) (X i) = 1
Theorem: intervalIntegrable_inv_iff
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

tactic: simp only [← intervalIntegrable_sub_inv_iff, sub_zero]
state_before: E : Type ?u.35816
F : Type ?u.35819
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b : ℝ
⊢ IntervalIntegrable (fun x => x⁻¹) volume a b ↔ a = b ∨ ¬0 ∈ [[a, b]]
Theorem: Nat.mem_factors_mul
File: Mathlib/Data/Nat/Factors.lean

tactic: rw [mem_factors (mul_ne_zero ha hb), mem_factors ha, mem_factors hb, ← and_or_left]
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ p ∈ factors (a * b) ↔ p ∈ factors a ∨ p ∈ factors b

tactic: simpa only [and_congr_right_iff] using Prime.dvd_mul
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ Prime p ∧ p ∣ a * b ↔ Prime p ∧ (p ∣ a ∨ p ∣ b)
Theorem: MeasureTheory.norm_integral_le_integral_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [integral_non_aestronglyMeasurable h, norm_zero]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1238187
𝕜 : Type ?u.1238190
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1240881
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α → E
le_ae : ∀ᵐ (a : α) ∂μ, 0 ≤ ‖f a‖
h : ¬AEStronglyMeasurable f μ
⊢ ‖∫ (a : α), f a ∂μ‖ ≤ ∫ (a : α), ‖f a‖ ∂μ

tactic: exact integral_nonneg_of_ae le_ae
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1238187
𝕜 : Type ?u.1238190
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1240881
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α → E
le_ae : ∀ᵐ (a : α) ∂μ, 0 ≤ ‖f a‖
h : ¬AEStronglyMeasurable f μ
⊢ 0 ≤ ∫ (a : α), ‖f a‖ ∂μ
Theorem: minpoly.root
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: have key : minpoly A x = X - C y := eq_of_monic_of_associated (monic hx) (monic_X_sub_C y)
  (associated_of_dvd_dvd ((irreducible_X_sub_C y).dvd_symm (irreducible hx) (dvd_iff_isRoot.2 h))
    (dvd_iff_isRoot.2 h))
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x✝ x : B
hx : IsIntegral A x
y : A
h : IsRoot (minpoly A x) y
⊢ ↑(algebraMap A B) y = x

tactic: have := aeval A x
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x✝ x : B
hx : IsIntegral A x
y : A
h : IsRoot (minpoly A x) y
key : minpoly A x = X - ↑C y
⊢ ↑(algebraMap A B) y = x

tactic: rwa [key, AlgHom.map_sub, aeval_X, aeval_C, sub_eq_zero, eq_comm] at this
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x✝ x : B
hx : IsIntegral A x
y : A
h : IsRoot (minpoly A x) y
key : minpoly A x = X - ↑C y
this : ↑(Polynomial.aeval x) (minpoly A x) = 0
⊢ ↑(algebraMap A B) y = x
Theorem: Finset.inter_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [inter_comm, univ_inter]
state_before: α : Type u_1
β : Type ?u.21491
γ : Type ?u.21494
inst✝¹ : Fintype α
s✝ t : Finset α
inst✝ : DecidableEq α
s : Finset α
⊢ s ∩ univ = s
Theorem: Nat.gcd_div
File: Std/Data/Nat/Gcd.lean

tactic: simp [H0]
state_before: m n k : Nat
H1 : k ∣ m
H2 : k ∣ n
H0 : k = 0
⊢ gcd (m / k) (n / k) = gcd m n / k

tactic: apply Nat.eq_of_mul_eq_mul_right H3
state_before: m n k : Nat
H1 : k ∣ m
H2 : k ∣ n
H3 : k > 0
⊢ gcd (m / k) (n / k) = gcd m n / k

tactic: rw [Nat.div_mul_cancel (dvd_gcd H1 H2), ← gcd_mul_right,
    Nat.div_mul_cancel H1, Nat.div_mul_cancel H2]
state_before: m n k : Nat
H1 : k ∣ m
H2 : k ∣ n
H3 : k > 0
⊢ gcd (m / k) (n / k) * k = gcd m n / k * k
Theorem: Finset.nonMemberSubfamily_memberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: ext
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ nonMemberSubfamily a (memberSubfamily a 𝒜) = memberSubfamily a 𝒜

tactic: simp
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
a✝ : Finset α
⊢ a✝ ∈ nonMemberSubfamily a (memberSubfamily a 𝒜) ↔ a✝ ∈ memberSubfamily a 𝒜
Theorem: Nat.coprime_of_mul_modEq_one
File: Mathlib/Data/Nat/ModEq.lean

tactic: obtain ⟨g, hh⟩ := Nat.gcd_dvd_right a n
state_before: m n✝ a✝ b✝ c d b a n : ℕ
h : a * b ≡ 1 [MOD n]
⊢ coprime a n

tactic: rw [Nat.coprime_iff_gcd_eq_one, ← Nat.dvd_one, ← Nat.modEq_zero_iff_dvd]
state_before: case intro
m n✝ a✝ b✝ c d b a n : ℕ
h : a * b ≡ 1 [MOD n]
g : ℕ
hh : n = gcd a n * g
⊢ coprime a n

tactic: calc
  1 ≡ a * b [MOD a.gcd n] := (hh ▸ h).symm.of_mul_right g
  _ ≡ 0 * b [MOD a.gcd n] := (Nat.modEq_zero_iff_dvd.mpr (Nat.gcd_dvd_left _ _)).mul_right b
  _ = 0 := by rw [zero_mul]
state_before: case intro
m n✝ a✝ b✝ c d b a n : ℕ
h : a * b ≡ 1 [MOD n]
g : ℕ
hh : n = gcd a n * g
⊢ 1 ≡ 0 [MOD gcd a n]

tactic: rw [zero_mul]
state_before: m n✝ a✝ b✝ c d b a n : ℕ
h : a * b ≡ 1 [MOD n]
g : ℕ
hh : n = gcd a n * g
⊢ 0 * b = 0
Theorem: Mathlib.Meta.NormNum.isNat_cast
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rintro ⟨⟨⟩⟩
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n m : ℕ
⊢ IsNat n m → IsNat (↑n) m

tactic: exact ⟨rfl⟩
state_before: case mk.refl
R : Type u_1
inst✝ : AddMonoidWithOne R
m : ℕ
⊢ IsNat (↑↑m) m
Theorem: antilipschitzWith_iff_le_mul_nndist
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simp only [AntilipschitzWith, edist_nndist]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1159
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ AntilipschitzWith K f ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)

tactic: norm_cast
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1159
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ (∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))) ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)
Theorem: MulAction.orbitRel.Quotient.mem_orbit
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: induction x using Quotient.inductionOn'
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
b : β
x : Quotient α β
⊢ b ∈ orbit x ↔ Quotient.mk'' b = x

tactic: rw [Quotient.eq'']
state_before: case h
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
b a✝ : β
⊢ b ∈ orbit (Quotient.mk'' a✝) ↔ Quotient.mk'' b = Quotient.mk'' a✝

tactic: rfl
state_before: case h
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
b a✝ : β
⊢ b ∈ orbit (Quotient.mk'' a✝) ↔ Setoid.r b a✝
Theorem: VectorBundleCore.mem_source_at
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [localTrivAt, mem_localTriv_source]
state_before: R : Type u_3
B : Type u_1
F : Type u_2
E : B → Type ?u.424723
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b : B
a : F
i j : ι
⊢ { fst := b, snd := a } ∈ (localTrivAt Z b).toLocalHomeomorph.toLocalEquiv.source

tactic: exact Z.mem_baseSet_at b
state_before: R : Type u_3
B : Type u_1
F : Type u_2
E : B → Type ?u.424723
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b : B
a : F
i j : ι
⊢ { fst := b, snd := a }.fst ∈ baseSet Z (indexAt Z b)
Theorem: Rat.coe_nat_num
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [← Int.cast_ofNat, coe_int_num]
state_before: a b c : ℚ
n : ℕ
⊢ (↑n).num = ↑n
Theorem: Ideal.exists_pow_le_of_le_radical_of_fG
File: Mathlib/Algebra/Homology/LocalCohomology.lean

tactic: obtain ⟨k, hk⟩ := J.exists_radical_pow_le_of_fg hJ
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
hIJ : I ≤ radical J
hJ : FG (radical J)
⊢ ∃ k, I ^ k ≤ J

tactic: use k
state_before: case intro
R : Type u
inst✝ : CommRing R
I J : Ideal R
hIJ : I ≤ radical J
hJ : FG (radical J)
k : ℕ
hk : radical J ^ k ≤ J
⊢ ∃ k, I ^ k ≤ J

tactic: calc
  I ^ k ≤ J.radical ^ k := Ideal.pow_mono hIJ _
  _ ≤ J := hk
state_before: case intro
R : Type u
inst✝ : CommRing R
I J : Ideal R
hIJ : I ≤ radical J
hJ : FG (radical J)
k : ℕ
hk : radical J ^ k ≤ J
⊢ I ^ k ≤ J
Theorem: Nat.SOM.Poly.mul_denote
File: src/lean/Init/Data/Nat/SOM.lean

tactic: simp [mul, go]
state_before: ctx : Context
p₁ p₂ : Poly
⊢ denote ctx (mul p₁ p₂) = denote ctx p₁ * denote ctx p₂

tactic: simp!
state_before: ctx : Context
p₁ p₂ : Poly
⊢ denote ctx [] + denote ctx p₁ * denote ctx p₂ = denote ctx p₁ * denote ctx p₂

tactic: match p₁ with
| [] => simp!
| (k, m) :: p₁ =>
  simp! [go p₁, Nat.left_distrib, add_denote, mulMon_denote,
         Nat.add_assoc, Nat.add_comm, Nat.add_left_comm,
         Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm]
state_before: ctx : Context
p₁✝ p₂ p₁ acc : Poly
⊢ denote ctx (mul.go p₂ p₁ acc) = denote ctx acc + denote ctx p₁ * denote ctx p₂

tactic: simp!
state_before: ctx : Context
p₁✝ p₂ p₁ acc : Poly
⊢ denote ctx (mul.go p₂ [] acc) = denote ctx acc + denote ctx [] * denote ctx p₂

tactic: simp! [go p₁, Nat.left_distrib, add_denote, mulMon_denote,
       Nat.add_assoc, Nat.add_comm, Nat.add_left_comm,
       Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm]
state_before: ctx : Context
p₁✝¹ p₂ p₁✝ acc : Poly
k : Nat
m : Mon
p₁ : List (Nat × Mon)
⊢ denote ctx (mul.go p₂ ((k, m) :: p₁) acc) = denote ctx acc + denote ctx ((k, m) :: p₁) * denote ctx p₂
Theorem: Subgroup.card_mul_index
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← relindex_bot_left, ← index_bot]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ Nat.card { x // x ∈ H } * index H = Nat.card G

tactic: exact relindex_mul_index bot_le
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ relindex ⊥ H * index H = index ⊥
Theorem: Nat.sub_lt_left_of_lt_add
File: Std/Data/Nat/Lemmas.lean

tactic: have := Nat.sub_le_sub_right (succ_le_of_lt h) n
state_before: n k m : Nat
H : n ≤ k
h : k < n + m
⊢ k - n < m

tactic: rwa [Nat.add_sub_cancel_left, Nat.succ_sub H] at this
state_before: n k m : Nat
H : n ≤ k
h : k < n + m
this : succ k - n ≤ n + m - n
⊢ k - n < m
Theorem: isOpen_prod_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [Prod.forall, mem_nhds_prod_iff', and_left_comm]
state_before: α : Type u
β : Type v
γ : Type ?u.47317
δ : Type ?u.47320
ε : Type ?u.47323
ζ : Type ?u.47326
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set (α × β)
⊢ (∀ (a : α × β), a ∈ s → s ∈ 𝓝 a) ↔
    ∀ (a : α) (b : β), (a, b) ∈ s → ∃ u v, IsOpen u ∧ IsOpen v ∧ a ∈ u ∧ b ∈ v ∧ u ×ˢ v ⊆ s
Theorem: Real.continuousAt_rpow_of_ne
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: rw [ne_iff_lt_or_gt] at hp
state_before: p : ℝ × ℝ
hp : p.fst ≠ 0
⊢ ContinuousAt (fun p => p.fst ^ p.snd) p

tactic: rw [continuousAt_congr (rpow_eq_nhds_of_neg hp)]
state_before: case inl
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst < 0
⊢ ContinuousAt (fun p => p.fst ^ p.snd) p

tactic: refine' ContinuousAt.mul _ (continuous_cos.continuousAt.comp _)
state_before: case inl
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst < 0
⊢ ContinuousAt (fun x => exp (log x.fst * x.snd) * cos (x.snd * π)) p

tactic: refine' continuous_exp.continuousAt.comp (ContinuousAt.mul _ continuous_snd.continuousAt)
state_before: case inl.refine'_1
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst < 0
⊢ ContinuousAt (fun x => exp (log x.fst * x.snd)) p

tactic: refine' (continuousAt_log _).comp continuous_fst.continuousAt
state_before: case inl.refine'_1
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst < 0
⊢ ContinuousAt (fun x => log x.fst) p

tactic: exact hp.ne
state_before: case inl.refine'_1
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst < 0
⊢ p.fst ≠ 0

tactic: exact continuous_snd.continuousAt.mul continuousAt_const
state_before: case inl.refine'_2
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst < 0
⊢ ContinuousAt (fun x => x.snd * π) p

tactic: rw [continuousAt_congr (rpow_eq_nhds_of_pos hp)]
state_before: case inr
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst > 0
⊢ ContinuousAt (fun p => p.fst ^ p.snd) p

tactic: refine' continuous_exp.continuousAt.comp (ContinuousAt.mul _ continuous_snd.continuousAt)
state_before: case inr
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst > 0
⊢ ContinuousAt (fun x => exp (log x.fst * x.snd)) p

tactic: refine' (continuousAt_log _).comp continuous_fst.continuousAt
state_before: case inr
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst > 0
⊢ ContinuousAt (fun x => log x.fst) p

tactic: exact hp.lt.ne.symm
state_before: case inr
p : ℝ × ℝ
hp✝ : p.fst ≠ 0
hp : p.fst > 0
⊢ p.fst ≠ 0
Theorem: Array.appendList_data
File: Std/Data/Array/Init/Lemmas.lean

tactic: rw [← appendList_eq_append]
state_before: α : Type u_1
arr : Array α
l : List α
⊢ (arr ++ l).data = arr.data ++ l

tactic: unfold Array.appendList
state_before: α : Type u_1
arr : Array α
l : List α
⊢ (Array.appendList arr l).data = arr.data ++ l

tactic: induction l generalizing arr <;> simp [*]
state_before: α : Type u_1
arr : Array α
l : List α
⊢ (List.foldl (fun r v => push r v) arr l).data = arr.data ++ l
Theorem: Homeomorph.comap_nhds_eq
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [h.nhds_eq_comap, h.apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69386
δ : Type ?u.69389
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
y : β
⊢ comap (↑h) (𝓝 y) = 𝓝 (↑(Homeomorph.symm h) y)
Theorem: Nat.one_le_div_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [le_div_iff_mul_le hb, one_mul]
state_before: m n k a b : ℕ
hb : 0 < b
⊢ 1 ≤ a / b ↔ b ≤ a