tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Lp.cauchySeq_Lp_iff_cauchySeq_ℒp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp_rw [cauchySeq_iff_tendsto_dist_atTop_0, dist_def]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8132571
G : Type ?u.8132574
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
ι : Type u_1
inst✝¹ : Nonempty ι
inst✝ : SemilatticeSup ι
hp : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
⊢ CauchySeq f ↔ Tendsto (fun n => snorm (↑↑(f n.fst) - ↑↑(f n.snd)) p μ) atTop (𝓝 0)

tactic: rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff (fun n => ?_) ENNReal.zero_ne_top]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8132571
G : Type ?u.8132574
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
ι : Type u_1
inst✝¹ : Nonempty ι
inst✝ : SemilatticeSup ι
hp : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
⊢ Tendsto (fun n => ENNReal.toReal (snorm (↑↑(f n.fst) - ↑↑(f n.snd)) p μ)) atTop (𝓝 0) ↔
    Tendsto (fun n => snorm (↑↑(f n.fst) - ↑↑(f n.snd)) p μ) atTop (𝓝 0)

tactic: rw [snorm_congr_ae (Lp.coeFn_sub _ _).symm]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8132571
G : Type ?u.8132574
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
ι : Type u_1
inst✝¹ : Nonempty ι
inst✝ : SemilatticeSup ι
hp : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
n : ι × ι
⊢ snorm (↑↑(f n.fst) - ↑↑(f n.snd)) p μ ≠ ⊤

tactic: exact snorm_ne_top _
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8132571
G : Type ?u.8132574
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedAddCommGroup G
ι : Type u_1
inst✝¹ : Nonempty ι
inst✝ : SemilatticeSup ι
hp : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
n : ι × ι
⊢ snorm (↑↑(f n.fst - f n.snd)) p μ ≠ ⊤
Theorem: Metric.thickening_singleton
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: ext
state_before: ι : Sort ?u.95281
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
x : X
⊢ thickening δ {x} = ball x δ

tactic: simp [mem_thickening_iff]
state_before: case h
ι : Sort ?u.95281
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝¹ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
x x✝ : X
⊢ x✝ ∈ thickening δ {x} ↔ x✝ ∈ ball x δ
Theorem: Polynomial.quotient_mul_add_remainder_eq_aux
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp only [h, MulZeroClass.zero_mul, mod, modByMonic_zero, zero_add]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : q = 0
⊢ q * div p q + mod p q = p

tactic: conv =>
  rhs
  rw [← modByMonic_add_div p (monic_mul_leadingCoeff_inv h)]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * div p q + mod p q = p

tactic: rw [div, mod, add_comm, mul_assoc]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * div p q + mod p q =
    p %ₘ (q * ↑C (leadingCoeff q)⁻¹) + q * ↑C (leadingCoeff q)⁻¹ * (p /ₘ (q * ↑C (leadingCoeff q)⁻¹))
Theorem: Multiset.strongDownwardInduction_eq
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [strongDownwardInduction]
state_before: α : Type u_1
β : Type ?u.78622
γ : Type ?u.78625
p : Multiset α → Sort u_2
n : ℕ
H : (t₁ : Multiset α) → ({t₂ : Multiset α} → ↑card t₂ ≤ n → t₁ < t₂ → p t₂) → ↑card t₁ ≤ n → p t₁
s : Multiset α
⊢ strongDownwardInduction H s = H s fun {t₂} ht _hst => strongDownwardInduction H t₂ ht
Theorem: disjoint_left_comm
File: Mathlib/Order/Disjoint.lean

tactic: simp_rw [disjoint_iff_inf_le, inf_left_comm]
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
a b c d : α
⊢ Disjoint a (b ⊓ c) ↔ Disjoint b (a ⊓ c)
Theorem: Nat.factorization_def
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simpa [factorization] using absurd pp
state_before: n p : ℕ
pp : Prime p
⊢ ↑(factorization n) p = padicValNat p n
Theorem: lt_inv_mul_iff_mul_lt
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_left a]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ b < a⁻¹ * c ↔ a * b < c

tactic: simp
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * b < a * (a⁻¹ * c) ↔ a * b < c
Theorem: AffineBasis.coord_apply_combination_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: classical simp only [coord_apply, hi, Finset.affineCombination_eq_linear_combination, if_true,
    mul_boole, hw, Function.comp_apply, smul_eq_mul, s.sum_ite_eq,
    s.map_affineCombination b w hw]
state_before: ι : Type u_1
ι' : Type ?u.100622
k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
hi : i ∈ s
w : ι → k
hw : Finset.sum s w = 1
⊢ ↑(coord b i) (↑(Finset.affineCombination k s ↑b) w) = w i

tactic: simp only [coord_apply, hi, Finset.affineCombination_eq_linear_combination, if_true,
mul_boole, hw, Function.comp_apply, smul_eq_mul, s.sum_ite_eq,
s.map_affineCombination b w hw]
state_before: ι : Type u_1
ι' : Type ?u.100622
k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
hi : i ∈ s
w : ι → k
hw : Finset.sum s w = 1
⊢ ↑(coord b i) (↑(Finset.affineCombination k s ↑b) w) = w i
Theorem: PowerSeries.le_order
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: induction n using PartENat.casesOn
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : PartENat
h : ∀ (i : ℕ), ↑i < n → ↑(coeff R i) φ = 0
⊢ n ≤ order φ

tactic: show _ ≤ _
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0
⊢ ⊤ ≤ order φ

tactic: rw [top_le_iff, order_eq_top]
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0
⊢ ⊤ ≤ order φ

tactic: ext i
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0
⊢ φ = 0

tactic: exact h _ (PartENat.natCast_lt_top i)
state_before: case a.h
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0
i : ℕ
⊢ ↑(coeff R i) φ = ↑(coeff R i) 0

tactic: apply nat_le_order
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n✝ : ℕ
h : ∀ (i : ℕ), ↑i < ↑n✝ → ↑(coeff R i) φ = 0
⊢ ↑n✝ ≤ order φ

tactic: simpa only [PartENat.coe_lt_coe] using h
state_before: case a.h
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n✝ : ℕ
h : ∀ (i : ℕ), ↑i < ↑n✝ → ↑(coeff R i) φ = 0
⊢ ∀ (i : ℕ), i < n✝ → ↑(coeff R i) φ = 0
Theorem: PowerSeries.X_prime
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← Ideal.span_singleton_prime]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ Prime X

tactic: exact span_X_isPrime
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ Ideal.IsPrime (Ideal.span {X})

tactic: intro h
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ X ≠ 0

tactic: simpa [map_zero (coeff R 1)] using congr_arg (coeff R 1) h
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
h : X = 0
⊢ False
Theorem: mem_ball_iff_norm''
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_ball, dist_eq_norm_div]
state_before: 𝓕 : Type ?u.92449
𝕜 : Type ?u.92452
α : Type ?u.92455
ι : Type ?u.92458
κ : Type ?u.92461
E : Type u_1
F : Type ?u.92467
G : Type ?u.92470
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ ball a r ↔ ‖b / a‖ < r
Theorem: CategoryTheory.isCoseparating_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [← isSeparating_op_iff, Set.unop_op]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set Cᵒᵖ
⊢ IsCoseparating (Set.unop 𝒢) ↔ IsSeparating 𝒢
Theorem: Turing.TM2.stmts_trans
File: Mathlib/Computability/TuringMachine.lean

tactic: simp only [stmts, Finset.mem_insertNone, Finset.mem_biUnion, Option.mem_def, Option.some.injEq,
  forall_eq', exists_imp, and_imp]
state_before: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
M : Λ → Stmt₂
S : Finset Λ
q₁ q₂ : Stmt₂
h₁ : q₁ ∈ stmts₁ q₂
⊢ some q₂ ∈ stmts M S → some q₁ ∈ stmts M S

tactic: exact fun l ls h₂ ↦ ⟨_, ls, stmts₁_trans h₂ h₁⟩
state_before: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
M : Λ → Stmt₂
S : Finset Λ
q₁ q₂ : Stmt₂
h₁ : q₁ ∈ stmts₁ q₂
⊢ ∀ (x : Λ), x ∈ S → q₂ ∈ stmts₁ (M x) → ∃ a, a ∈ S ∧ q₁ ∈ stmts₁ (M a)
Theorem: finprod_mem_eq_one_of_infinite
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod_mem_def]
state_before: α : Type u_1
β : Type ?u.202844
ι : Type ?u.202847
G : Type ?u.202850
M : Type u_2
N : Type ?u.202856
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hs : Set.Infinite (s ∩ mulSupport f)
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i) = 1

tactic: apply finprod_of_infinite_mulSupport
state_before: α : Type u_1
β : Type ?u.202844
ι : Type ?u.202847
G : Type ?u.202850
M : Type u_2
N : Type ?u.202856
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hs : Set.Infinite (s ∩ mulSupport f)
⊢ (∏ᶠ (a : α), mulIndicator s (fun i => f i) a) = 1

tactic: rwa [← mulSupport_mulIndicator] at hs
state_before: case hf
α : Type u_1
β : Type ?u.202844
ι : Type ?u.202847
G : Type ?u.202850
M : Type u_2
N : Type ?u.202856
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hs : Set.Infinite (s ∩ mulSupport f)
⊢ Set.Infinite (mulSupport fun i => mulIndicator s (fun i => f i) i)
Theorem: IsLocalizedModule.mk'_surjective
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: intro x
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type ?u.936326
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
⊢ Function.Surjective (Function.uncurry (mk' f))

tactic: obtain ⟨⟨m, s⟩, e : s • x = f m⟩ := IsLocalizedModule.surj S f x
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type ?u.936326
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
x : M'
⊢ ∃ a, Function.uncurry (mk' f) a = x

tactic: exact ⟨⟨m, s⟩, mk'_eq_iff.mpr e.symm⟩
state_before: case intro.mk
R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type ?u.936326
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
x : M'
m : M
s : { x // x ∈ S }
e : s • x = ↑f m
⊢ ∃ a, Function.uncurry (mk' f) a = x
Theorem: Int.lcm_comm
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm, Int.lcm]
state_before: i j : ℤ
⊢ lcm i j = lcm j i

tactic: exact Nat.lcm_comm _ _
state_before: i j : ℤ
⊢ Nat.lcm (natAbs i) (natAbs j) = Nat.lcm (natAbs j) (natAbs i)
Theorem: Filter.eventually_prod_principal_iff
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [eventually_iff, eventually_iff, mem_prod_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4102
δ : Type ?u.4105
ι : Sort ?u.4108
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ (∀ᶠ (x : α × β) in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, ∀ (y : β), y ∈ s → p (x, y)

tactic: simp only [mem_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4102
δ : Type ?u.4105
ι : Sort ?u.4108
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ {a | ∀ (b : β), b ∈ s → (a, b) ∈ {x | p x}} ∈ f ↔ {x | ∀ (y : β), y ∈ s → p (x, y)} ∈ f
Theorem: UV.card_compress
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: unfold compress
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
huv : card u = card v
a : Finset α
⊢ card (compress u v a) = card a

tactic: split_ifs with h
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
huv : card u = card v
a : Finset α
⊢ card (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) = card a

tactic: rw [card_sdiff (h.2.trans le_sup_left), sup_eq_union, card_disjoint_union h.1.symm, huv,
  add_tsub_cancel_right]
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
huv : card u = card v
a : Finset α
h : Disjoint u a ∧ v ≤ a
⊢ card ((a ⊔ u) \ v) = card a

tactic: rfl
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
huv : card u = card v
a : Finset α
h : ¬(Disjoint u a ∧ v ≤ a)
⊢ card a = card a
Theorem: CauSeq.inf_equiv_inf
File: Mathlib/Data/Real/CauSeq.lean

tactic: intro ε ε0
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
⊢ a₁ ⊓ b₁ ≈ a₂ ⊓ b₂

tactic: obtain ⟨ai, hai⟩ := ha ε ε0
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j) < ε

tactic: obtain ⟨bi, hbi⟩ := hb ε ε0
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ (j : ℕ), j ≥ ai → abs (↑(a₁ - a₂) j) < ε
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j) < ε

tactic: exact
  ⟨ai ⊔ bi, fun i hi =>
    (abs_min_sub_min_le_max (a₁ i) (b₁ i) (a₂ i) (b₂ i)).trans_lt
      (max_lt (hai i (sup_le_iff.mp hi).1) (hbi i (sup_le_iff.mp hi).2))⟩
state_before: case intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ (j : ℕ), j ≥ ai → abs (↑(a₁ - a₂) j) < ε
bi : ℕ
hbi : ∀ (j : ℕ), j ≥ bi → abs (↑(b₁ - b₂) j) < ε
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j) < ε
Theorem: MvPolynomial.comp_eval₂Hom
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: apply MvPolynomial.ringHom_ext
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
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
⊢ RingHom.comp φ (eval₂Hom f g) = eval₂Hom (RingHom.comp φ f) fun i => ↑φ (g i)

tactic: intro r
state_before: case hC
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
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
⊢ ∀ (r : R), ↑(RingHom.comp φ (eval₂Hom f g)) (↑C r) = ↑(eval₂Hom (RingHom.comp φ f) fun i => ↑φ (g i)) (↑C r)

tactic: rw [RingHom.comp_apply, eval₂Hom_C, eval₂Hom_C, RingHom.comp_apply]
state_before: case hC
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
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
r : R
⊢ ↑(RingHom.comp φ (eval₂Hom f g)) (↑C r) = ↑(eval₂Hom (RingHom.comp φ f) fun i => ↑φ (g i)) (↑C r)

tactic: intro i
state_before: case hX
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
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
⊢ ∀ (i : σ), ↑(RingHom.comp φ (eval₂Hom f g)) (X i) = ↑(eval₂Hom (RingHom.comp φ f) fun i => ↑φ (g i)) (X i)

tactic: rw [RingHom.comp_apply, eval₂Hom_X', eval₂Hom_X']
state_before: case hX
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
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
i : σ
⊢ ↑(RingHom.comp φ (eval₂Hom f g)) (X i) = ↑(eval₂Hom (RingHom.comp φ f) fun i => ↑φ (g i)) (X i)
Theorem: Homotopy.nullHomotopicMap_f
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp only [nullHomotopicMap]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
hom : (i j : ι) → X C i ⟶ X D j
⊢ Hom.f (nullHomotopicMap hom) k₁ = d C k₁ k₀ ≫ hom k₀ k₁ + hom k₁ k₂ ≫ d D k₂ k₁

tactic: rw [dNext_eq hom r₁₀, prevD_eq hom r₂₁]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
hom : (i j : ι) → X C i ⟶ X D j
⊢ ↑(dNext k₁) hom + ↑(prevD k₁) hom = d C k₁ k₀ ≫ hom k₀ k₁ + hom k₁ k₂ ≫ d D k₂ k₁
Theorem: isConj_iff₀
File: Mathlib/Algebra/Group/Conj.lean

tactic: rw [← Units.val_inv_eq_inv_val, Units.mul_inv_eq_iff_eq_mul]
state_before: α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : IsConj a b
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ ↑c ≠ 0 ∧ ↑c * a * (↑c)⁻¹ = b

tactic: exact ⟨c.ne_zero, hc⟩
state_before: α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : IsConj a b
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ ↑c ≠ 0 ∧ ↑c * a = b * ↑c

tactic: rw [SemiconjBy, ← Units.mul_inv_eq_iff_eq_mul, Units.val_inv_eq_inv_val, Units.val_mk0]
state_before: α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : ∃ c, c ≠ 0 ∧ c * a * c⁻¹ = b
c : α
c0 : c ≠ 0
hc : c * a * c⁻¹ = b
⊢ SemiconjBy (↑(Units.mk0 c c0)) a b

tactic: exact hc
state_before: α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : ∃ c, c ≠ 0 ∧ c * a * c⁻¹ = b
c : α
c0 : c ≠ 0
hc : c * a * c⁻¹ = b
⊢ c * a * c⁻¹ = b
Theorem: Ordinal.principal_add_of_principal_mul_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: have := ho ((opow_lt_opow_iff_right hb).2 hx) ((opow_lt_opow_iff_right hb).2 hy)
state_before: o b : Ordinal
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal
hx : x < o
hy : y < o
⊢ (fun x x_1 => x + x_1) x y < o

tactic: dsimp only at *
state_before: o b : Ordinal
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal
hx : x < o
hy : y < o
this : (fun x x_1 => x * x_1) (b ^ x) (b ^ y) < b ^ o
⊢ (fun x x_1 => x + x_1) x y < o

tactic: rwa [← opow_add, opow_lt_opow_iff_right hb] at this
state_before: o b : Ordinal
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal
hx : x < o
hy : y < o
this : b ^ x * b ^ y < b ^ o
⊢ x + y < o
Theorem: lp.norm_apply_le_of_tendsto
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: have : Tendsto (fun k => ‖F k a‖) l (𝓝 ‖f a‖) :=
  (Tendsto.comp (continuous_apply a).continuousAt hf).norm
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
l : Filter ι
inst✝ : NeBot l
C : ℝ
F : ι → { x // x ∈ lp E ⊤ }
hCF : ∀ᶠ (k : ι) in l, ‖F k‖ ≤ C
f : (a : α) → E a
hf : Tendsto (id fun i => ↑(F i)) l (𝓝 f)
a : α
⊢ ‖f a‖ ≤ C

tactic: refine' le_of_tendsto this (hCF.mono _)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
l : Filter ι
inst✝ : NeBot l
C : ℝ
F : ι → { x // x ∈ lp E ⊤ }
hCF : ∀ᶠ (k : ι) in l, ‖F k‖ ≤ C
f : (a : α) → E a
hf : Tendsto (id fun i => ↑(F i)) l (𝓝 f)
a : α
this : Tendsto (fun k => ‖↑(F k) a‖) l (𝓝 ‖f a‖)
⊢ ‖f a‖ ≤ C

tactic: intro k hCFk
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
l : Filter ι
inst✝ : NeBot l
C : ℝ
F : ι → { x // x ∈ lp E ⊤ }
hCF : ∀ᶠ (k : ι) in l, ‖F k‖ ≤ C
f : (a : α) → E a
hf : Tendsto (id fun i => ↑(F i)) l (𝓝 f)
a : α
this : Tendsto (fun k => ‖↑(F k) a‖) l (𝓝 ‖f a‖)
⊢ ∀ (x : ι), ‖F x‖ ≤ C → ‖↑(F x) a‖ ≤ C

tactic: exact (norm_apply_le_norm ENNReal.top_ne_zero (F k) a).trans hCFk
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
l : Filter ι
inst✝ : NeBot l
C : ℝ
F : ι → { x // x ∈ lp E ⊤ }
hCF : ∀ᶠ (k : ι) in l, ‖F k‖ ≤ C
f : (a : α) → E a
hf : Tendsto (id fun i => ↑(F i)) l (𝓝 f)
a : α
this : Tendsto (fun k => ‖↑(F k) a‖) l (𝓝 ‖f a‖)
k : ι
hCFk : ‖F k‖ ≤ C
⊢ ‖↑(F k) a‖ ≤ C
Theorem: IsLocalMin.inv
File: Mathlib/Topology/Algebra/Field.lean

tactic: filter_upwards [h1, h2]with z h3 h4 using(inv_le_inv h4 h2.self_of_nhds).mpr h3
state_before: K : Type ?u.14947
inst✝³ : DivisionRing K
inst✝² : TopologicalSpace K
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedSemifield β
a✝ : α
f : α → β
a : α
h1 : IsLocalMin f a
h2 : ∀ᶠ (z : α) in 𝓝 a, 0 < f z
⊢ IsLocalMax f⁻¹ a
Theorem: Nat.add_sub_self_left
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction a with
| zero => simp
| succ a ih =>
  rw [Nat.succ_add, Nat.succ_sub_succ]
  apply ih
state_before: a b : Nat
⊢ a + b - a = b

tactic: simp
state_before: case zero
b : Nat
⊢ zero + b - zero = b

tactic: rw [Nat.succ_add, Nat.succ_sub_succ]
state_before: case succ
b a : Nat
ih : a + b - a = b
⊢ succ a + b - succ a = b

tactic: apply ih
state_before: case succ
b a : Nat
ih : a + b - a = b
⊢ a + b - a = b
Theorem: Fintype.bddBelow_range
File: Mathlib/Data/Fintype/Order.lean

tactic: obtain ⟨M, hM⟩ := Fintype.exists_ge f
state_before: α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≥ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
⊢ BddBelow (Set.range f)

tactic: refine' ⟨M, fun a ha => _⟩
state_before: case intro
α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≥ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
⊢ BddBelow (Set.range f)

tactic: obtain ⟨b, rfl⟩ := ha
state_before: case intro
α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≥ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
a : α
ha : a ∈ Set.range f
⊢ M ≤ a

tactic: exact hM b
state_before: case intro.intro
α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≥ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
b : β
⊢ M ≤ f b