tasksource/leandojo huggingface dataset:
Theorem: tendsto_nat_ceil_mul_div_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: have A : Tendsto (fun x : R => a + x⁻¹) atTop (𝓝 (a + 0)) :=
  tendsto_const_nhds.add tendsto_inv_atTop_zero
state_before: α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
⊢ Tendsto (fun x => ↑⌈a * x⌉₊ / x) atTop (𝓝 a)

tactic: rw [add_zero] at A
state_before: α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 (a + 0))
⊢ Tendsto (fun x => ↑⌈a * x⌉₊ / x) atTop (𝓝 a)

tactic: apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds A
state_before: α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 a)
⊢ Tendsto (fun x => ↑⌈a * x⌉₊ / x) atTop (𝓝 a)

tactic: refine' eventually_atTop.2 ⟨1, fun x hx => _⟩
state_before: case hgf
α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 a)
⊢ ∀ᶠ (b : R) in atTop, a ≤ ↑⌈a * b⌉₊ / b

tactic: rw [le_div_iff (zero_lt_one.trans_le hx)]
state_before: case hgf
α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 a)
x : R
hx : x ≥ 1
⊢ a ≤ ↑⌈a * x⌉₊ / x

tactic: exact Nat.le_ceil _
state_before: case hgf
α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 a)
x : R
hx : x ≥ 1
⊢ a * x ≤ ↑⌈a * x⌉₊

tactic: refine' eventually_atTop.2 ⟨1, fun x hx => _⟩
state_before: case hfh
α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 a)
⊢ ∀ᶠ (b : R) in atTop, ↑⌈a * b⌉₊ / b ≤ a + b⁻¹

tactic: simp [div_le_iff (zero_lt_one.trans_le hx), inv_mul_cancel (zero_lt_one.trans_le hx).ne',
  (Nat.ceil_lt_add_one (mul_nonneg ha (zero_le_one.trans hx))).le, add_mul]
state_before: case hfh
α : Type ?u.516691
β : Type ?u.516694
ι : Type ?u.516697
R : Type u_1
inst✝³ : TopologicalSpace R
inst✝² : LinearOrderedField R
inst✝¹ : OrderTopology R
inst✝ : FloorRing R
a : R
ha : 0 ≤ a
A : Tendsto (fun x => a + x⁻¹) atTop (𝓝 a)
x : R
hx : x ≥ 1
⊢ ↑⌈a * x⌉₊ / x ≤ a + x⁻¹
Theorem: Finset.univ_prod_mulSingle
File: Mathlib/Algebra/BigOperators/Pi.lean

tactic: ext a
state_before: I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
⊢ ∏ i : I, Pi.mulSingle i (f i) = f

tactic: simp
state_before: case h
I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
a : I
⊢ Finset.prod univ (fun i => Pi.mulSingle i (f i)) a = f a
Theorem: Int.add_lt_of_lt_sub_left
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_left h a
state_before: a b c : Int
h : b < c - a
⊢ a + b < c

tactic: rwa [← Int.add_sub_assoc, Int.add_comm a c, Int.add_sub_cancel] at h
state_before: a b c : Int
h✝ : b < c - a
h : a + b < a + (c - a)
⊢ a + b < c
Theorem: CategoryTheory.Limits.isIso_π_of_isTerminal
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: ext
state_before: C : Type u₁
inst✝³ : Category C
J : Type u
inst✝² : Category J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
⊢ limit.π F j ≫ limit.lift F (coneOfDiagramTerminal I F) = 𝟙 (limit F)

tactic: simp
state_before: case w
C : Type u₁
inst✝³ : Category C
J : Type u
inst✝² : Category J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
j✝ : J
⊢ (limit.π F j ≫ limit.lift F (coneOfDiagramTerminal I F)) ≫ limit.π F j✝ = 𝟙 (limit F) ≫ limit.π F j✝

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
J : Type u
inst✝² : Category J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : ∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)
⊢ limit.lift F (coneOfDiagramTerminal I F) ≫ limit.π F j = 𝟙 (F.obj j)
Theorem: Bool.or_eq_true_eq_eq_true_or_eq_true
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: simp
state_before: a b : Bool
⊢ ((a || b) = true) = (a = true ∨ b = true)
Theorem: Nat.add_eq_one_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: cases n <;> simp [succ_eq_add_one, ← add_assoc, succ_inj']
state_before: m n k l : ℕ
⊢ m + n = 1 ↔ m = 0 ∧ n = 1 ∨ m = 1 ∧ n = 0
Theorem: Complex.int_cast_re
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [← ofReal_int_cast, ofReal_re]
state_before: n : ℤ
⊢ (↑n).re = ↑n
Theorem: Mathlib.Tactic.Ring.neg_one_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R✝ : Type ?u.203351
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : Ring R
a b : R
x✝ : Int.rawCast (Int.negOfNat 1) * a = b
⊢ -a = b

tactic: simp [Int.negOfNat]
state_before: u : Lean.Level
R✝ : Type ?u.203351
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : Ring R
a : R
⊢ -a = Int.rawCast (Int.negOfNat 1) * a
Theorem: SimpleGraph.Walk.concat_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [concat_eq_append, ← append_assoc, cons_nil_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x : V
p : Walk G u v
h : Adj G v w
q : Walk G w x
⊢ append (concat p h) q = append p (cons h q)
Theorem: List.filter_sublist
File: Std/Data/List/Lemmas.lean

tactic: rw [filter]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
⊢ filter p (a :: l) <+ a :: l

tactic: split <;> simp [Sublist.cons, Sublist.cons₂, filter_sublist l]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
⊢ (match p a with
    | true => a :: filter p l
    | false => filter p l) <+
    a :: l
Theorem: intervalIntegral.integral_eq_zero_iff_of_le_of_nonneg_ae
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [integral_of_le hab, integral_eq_zero_iff_of_nonneg_ae hf hfi.1]
state_before: ι : Type ?u.19335522
𝕜 : Type ?u.19335525
E : Type ?u.19335528
F : Type ?u.19335531
A : Type ?u.19335534
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hf : 0 ≤ᵐ[Measure.restrict μ (Ioc a b)] f
hfi : IntervalIntegrable f μ a b
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = 0 ↔ f =ᵐ[Measure.restrict μ (Ioc a b)] 0
Theorem: NNReal.iInf_empty
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [iInf_of_empty', sInf_empty]
state_before: ι : Sort u_1
f✝ : ι → ℝ≥0
inst✝ : IsEmpty ι
f : ι → ℝ≥0
⊢ (⨅ (i : ι), f i) = 0
Theorem: Nat.Prime.factorization
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext q
state_before: p : ℕ
hp : Prime p
⊢ Nat.factorization p = single p 1

tactic: rw [← factors_count_eq, factors_prime hp, single_apply, count_singleton', if_congr eq_comm] <;>
  rfl
state_before: case h
p : ℕ
hp : Prime p
q : ℕ
⊢ ↑(Nat.factorization p) q = ↑(single p 1) q
Theorem: Computation.ret_orElse
File: Mathlib/Data/Seq/Computation.lean

tactic: unfold HOrElse.hOrElse instHOrElse
state_before: α : Type u
β : Type v
γ : Type w
a : α
c₂ : Computation α
⊢ destruct (HOrElse.hOrElse (pure a) fun x => c₂) = Sum.inl a

tactic: unfold OrElse.orElse instOrElse Alternative.orElse instAlternativeComputation
state_before: α : Type u
β : Type v
γ : Type w
a : α
c₂ : Computation α
⊢ destruct ({ hOrElse := fun a b => OrElse.orElse a b }.1 (pure a) fun x => c₂) = Sum.inl a

tactic: simp [orElse]
state_before: α : Type u
β : Type v
γ : Type w
a : α
c₂ : Computation α
⊢ destruct
      ({
            hOrElse := fun a b =>
              {
                    orElse :=
                      (let src := monad;
                        Alternative.mk empty @orElse).3 }.1
                a b }.1
        (pure a) fun x => c₂) =
    Sum.inl a
Theorem: image_segment
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp_rw [segment_eq_image_lineMap, mem_image, exists_exists_and_eq_and, AffineMap.apply_lineMap]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.97868
ι : Type ?u.97871
π : ι → Type ?u.97876
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
f : E →ᵃ[𝕜] F
a b : E
x : F
⊢ x ∈ ↑f '' [a-[𝕜]b] ↔ x ∈ [↑f a-[𝕜]↑f b]
Theorem: Filter.eventually_or_distrib_left
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.143807
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x

tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.143807
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : ¬p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
Theorem: HasFDerivAtFilter.add
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [LinearMap.sub_apply, LinearMap.add_apply, map_sub, map_add, add_apply]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.127337
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.127432
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasFDerivAtFilter f f' x L
hg : HasFDerivAtFilter g g' x L
x✝ : E
⊢ f x✝ - f x - ↑f' (x✝ - x) + (g x✝ - g x - ↑g' (x✝ - x)) =
    (fun y => f y + g y) x✝ - (fun y => f y + g y) x - ↑(f' + g') (x✝ - x)

tactic: abel
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.127337
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.127432
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasFDerivAtFilter f f' x L
hg : HasFDerivAtFilter g g' x L
x✝ : E
⊢ f x✝ - f x - (↑f' x✝ - ↑f' x) + (g x✝ - g x - (↑g' x✝ - ↑g' x)) =
    f x✝ + g x✝ - (f x + g x) - (↑f' x✝ + ↑g' x✝ - (↑f' x + ↑g' x))
Theorem: pi_norm_lt_iff'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [← dist_one_right, dist_pi_lt_iff hr, Pi.one_apply]
state_before: 𝓕 : Type ?u.1270061
𝕜 : Type ?u.1270064
α : Type ?u.1270067
ι : Type u_1
κ : Type ?u.1270073
E : Type ?u.1270076
F : Type ?u.1270079
G : Type ?u.1270082
π : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → SeminormedGroup (π i)
inst✝ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
hr : 0 < r
⊢ ‖x‖ < r ↔ ∀ (i : ι), ‖x i‖ < r
Theorem: matPolyEquiv_smul_one
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: ext (m i j)
state_before: R : Type u_1
A : Type ?u.620220
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : R[X]
⊢ ↑matPolyEquiv (p • 1) = Polynomial.map (algebraMap R (Matrix n n R)) p

tactic: simp only [coeff_map, one_apply, algebraMap_matrix_apply, mul_boole, Pi.smul_apply,
  matPolyEquiv_coeff_apply]
state_before: case a.a.h
R : Type u_1
A : Type ?u.620220
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : R[X]
m : ℕ
i j : n
⊢ coeff (↑matPolyEquiv (p • 1)) m i j = coeff (Polynomial.map (algebraMap R (Matrix n n R)) p) m i j

tactic: split_ifs <;> simp <;> rename_i h <;> simp [h]
state_before: case a.a.h
R : Type u_1
A : Type ?u.620220
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : R[X]
m : ℕ
i j : n
⊢ coeff ((p • 1) i j) m = if i = j then ↑(algebraMap R R) (coeff p m) else 0
Theorem: Std.RBNode.balance2_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: unfold balance2
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList (balance2 l v r) = toList l ++ v :: toList r

tactic: split <;> simp
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList
      (match l, v, r with
      | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
      | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b) =
    toList l ++ v :: toList r
Theorem: Set.one_le_chainHeight_iff
File: Mathlib/Order/Height.lean

tactic: rw [← Nat.cast_one, Set.le_chainHeight_iff]
state_before: α : Type u_1
β : Type ?u.7989
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ 1 ≤ chainHeight s ↔ Set.Nonempty s

tactic: simp only [length_eq_one, @and_comm (_ ∈ _), @eq_comm _ _ [_], exists_exists_eq_and,
  singleton_mem_subchain_iff, Set.Nonempty]
state_before: α : Type u_1
β : Type ?u.7989
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ (∃ l, l ∈ subchain s ∧ length l = 1) ↔ Set.Nonempty s
Theorem: Nat.findGreatest_eq_zero_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: simp [findGreatest_eq_iff]
state_before: m n k l : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
⊢ Nat.findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n
Theorem: Int.le_add_of_nonneg_right
File: Std/Data/Int/Lemmas.lean

tactic: have : a + b ≥ a + 0 := Int.add_le_add_left h a
state_before: a b : Int
h : 0 ≤ b
⊢ a ≤ a + b

tactic: rwa [Int.add_zero] at this
state_before: a b : Int
h : 0 ≤ b
this : a + b ≥ a + 0
⊢ a ≤ a + b
Theorem: comp_open_symm_mem_uniformity_sets
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: obtain ⟨t, ht₁, ht₂⟩ := comp_mem_uniformity_sets hs
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.94197
inst✝ : UniformSpace α
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ ∃ t, t ∈ 𝓤 α ∧ IsOpen t ∧ SymmetricRel t ∧ t ○ t ⊆ s

tactic: obtain ⟨u, ⟨hu₁, hu₂, hu₃⟩, hu₄ : u ⊆ t⟩ := uniformity_hasBasis_open_symmetric.mem_iff.mp ht₁
state_before: case intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.94197
inst✝ : UniformSpace α
s : Set (α × α)
hs : s ∈ 𝓤 α
t : Set (α × α)
ht₁ : t ∈ 𝓤 α
ht₂ : t ○ t ⊆ s
⊢ ∃ t, t ∈ 𝓤 α ∧ IsOpen t ∧ SymmetricRel t ∧ t ○ t ⊆ s

tactic: exact ⟨u, hu₁, hu₂, hu₃, (compRel_mono hu₄ hu₄).trans ht₂⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.94197
inst✝ : UniformSpace α
s : Set (α × α)
hs : s ∈ 𝓤 α
t : Set (α × α)
ht₁ : t ∈ 𝓤 α
ht₂ : t ○ t ⊆ s
u : Set (α × α)
hu₄ : u ⊆ t
hu₁ : u ∈ 𝓤 α
hu₂ : IsOpen u
hu₃ : SymmetricRel u
⊢ ∃ t, t ∈ 𝓤 α ∧ IsOpen t ∧ SymmetricRel t ∧ t ○ t ⊆ s
Theorem: Nat.ArithmeticFunction.IsMultiplicative.ppow
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: induction' k with k hi
state_before: R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
hf : IsMultiplicative f
k : ℕ
⊢ IsMultiplicative (ArithmeticFunction.ppow f k)

tactic: exact isMultiplicative_zeta.nat_cast
state_before: case zero
R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
hf : IsMultiplicative f
⊢ IsMultiplicative (ArithmeticFunction.ppow f Nat.zero)

tactic: rw [ppow_succ]
state_before: case succ
R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
hf : IsMultiplicative f
k : ℕ
hi : IsMultiplicative (ArithmeticFunction.ppow f k)
⊢ IsMultiplicative (ArithmeticFunction.ppow f (succ k))

tactic: apply hf.pmul hi
state_before: case succ
R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
hf : IsMultiplicative f
k : ℕ
hi : IsMultiplicative (ArithmeticFunction.ppow f k)
⊢ IsMultiplicative (ArithmeticFunction.pmul f (ArithmeticFunction.ppow f k))
Theorem: toIcoMod_sub_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIcoMod_add_zsmul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp a (b - m • p) = toIcoMod hp a b
Theorem: MeasureTheory.Measure.ext_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rintro rfl s _hs
state_before: α : Type u_1
β : Type ?u.10223
γ : Type ?u.10226
δ : Type ?u.10229
ι : Type ?u.10232
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ μ₁ = μ₂ → ∀ (s : Set α), MeasurableSet s → ↑↑μ₁ s = ↑↑μ₂ s

tactic: rfl
state_before: α : Type u_1
β : Type ?u.10223
γ : Type ?u.10226
δ : Type ?u.10229
ι : Type ?u.10232
inst✝ : MeasurableSpace α
μ μ₁ : Measure α
s✝ s₁ s₂ t s : Set α
_hs : MeasurableSet s
⊢ ↑↑μ₁ s = ↑↑μ₁ s
Theorem: char_eq_expChar_iff
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: cases' hq with q hq_one hq_prime hq_hchar
state_before: R : Type u
inst✝ : Semiring R
p q : ℕ
hp : CharP R p
hq : ExpChar R q
⊢ p = q ↔ Nat.Prime p

tactic: rw [(CharP.eq R hp inferInstance : p = 0)]
state_before: case zero
R : Type u
inst✝ : Semiring R
p : ℕ
hp : CharP R p
q : CharZero R
⊢ p = 1 ↔ Nat.Prime p

tactic: decide
state_before: case zero
R : Type u
inst✝ : Semiring R
p : ℕ
hp : CharP R p
q : CharZero R
⊢ 0 = 1 ↔ Nat.Prime 0

tactic: exact ⟨fun hpq => hpq.symm ▸ hq_prime, fun _ => CharP.eq R hp hq_hchar⟩
state_before: case prime
R : Type u
inst✝ : Semiring R
p q : ℕ
hp : CharP R p
hq_prime : Nat.Prime q
hq_hchar : CharP R q
⊢ p = q ↔ Nat.Prime p
Theorem: LinearMap.ker_id_sub_eq_of_proj
File: Mathlib/LinearAlgebra/Projection.lean

tactic: ext x
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.9010
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.9526
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.10489
inst✝² : Semiring S
M : Type ?u.10495
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : E →ₗ[R] { x // x ∈ p }
hf : ∀ (x : { x // x ∈ p }), ↑f ↑x = x
⊢ ker (id - comp (Submodule.subtype p) f) = p

tactic: simp only [comp_apply, mem_ker, subtype_apply, sub_apply, id_apply, sub_eq_zero]
state_before: case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.9010
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.9526
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.10489
inst✝² : Semiring S
M : Type ?u.10495
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : E →ₗ[R] { x // x ∈ p }
hf : ∀ (x : { x // x ∈ p }), ↑f ↑x = x
x : E
⊢ x ∈ ker (id - comp (Submodule.subtype p) f) ↔ x ∈ p

tactic: exact ⟨fun h => h.symm ▸ Submodule.coe_mem _, fun hx => by erw [hf ⟨x, hx⟩, Subtype.coe_mk]⟩
state_before: case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.9010
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.9526
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.10489
inst✝² : Semiring S
M : Type ?u.10495
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : E →ₗ[R] { x // x ∈ p }
hf : ∀ (x : { x // x ∈ p }), ↑f ↑x = x
x : E
⊢ x = ↑(↑f x) ↔ x ∈ p

tactic: erw [hf ⟨x, hx⟩, Subtype.coe_mk]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.9010
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.9526
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.10489
inst✝² : Semiring S
M : Type ?u.10495
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : E →ₗ[R] { x // x ∈ p }
hf : ∀ (x : { x // x ∈ p }), ↑f ↑x = x
x : E
hx : x ∈ p
⊢ x = ↑(↑f x)
Theorem: BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: cases nonempty_fintype ι
state_before: ι : Type u_1
M : Type ?u.49727
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
s : Finset (Box ι)
⊢ ∀ᶠ (t : Finset (ι × ℝ)) in atTop,
    ∀ (I J : Box ι), J ∈ s → ∀ (J' : Box ι), J' ∈ splitMany I t → ¬Disjoint ↑J ↑J' → J' ≤ J

tactic: refine' eventually_atTop.2
  ⟨s.biUnion fun J => Finset.univ.biUnion fun i => {(i, J.lower i), (i, J.upper i)},
    fun t ht I J hJ J' hJ' => not_disjoint_imp_le_of_subset_of_mem_splitMany (fun i => _) hJ'⟩
state_before: case intro
ι : Type u_1
M : Type ?u.49727
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
s : Finset (Box ι)
val✝ : Fintype ι
⊢ ∀ᶠ (t : Finset (ι × ℝ)) in atTop,
    ∀ (I J : Box ι), J ∈ s → ∀ (J' : Box ι), J' ∈ splitMany I t → ¬Disjoint ↑J ↑J' → J' ≤ J

tactic: exact fun p hp =>
  ht (Finset.mem_biUnion.2 ⟨J, hJ, Finset.mem_biUnion.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
state_before: case intro
ι : Type u_1
M : Type ?u.49727
n : ℕ
I✝ J✝ : Box ι
i✝ : ι
x : ℝ
inst✝ : Finite ι
s : Finset (Box ι)
val✝ : Fintype ι
t : Finset (ι × ℝ)
ht : t ≥ Finset.biUnion s fun J => Finset.biUnion Finset.univ fun i => {(i, Box.lower J i), (i, Box.upper J i)}
I J : Box ι
hJ : J ∈ s
J' : Box ι
hJ' : J' ∈ splitMany I t
i : ι
⊢ {(i, Box.lower J i), (i, Box.upper J i)} ⊆ t
Theorem: Multiset.toFinsupp_support
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.58480
ι : Type ?u.58483
inst✝ : DecidableEq α
s : Multiset α
⊢ (↑toFinsupp s).support = toFinset s

tactic: simp [toFinsupp]
state_before: case a
α : Type u_1
β : Type ?u.58480
ι : Type ?u.58483
inst✝ : DecidableEq α
s : Multiset α
a✝ : α
⊢ a✝ ∈ (↑toFinsupp s).support ↔ a✝ ∈ toFinset s
Theorem: lp.norm_le_of_forall_le
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: cases isEmpty_or_nonempty α
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
C : ℝ
hC : 0 ≤ C
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
⊢ ‖f‖ ≤ C

tactic: simpa [eq_zero' f] using hC
state_before: case inl
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
C : ℝ
hC : 0 ≤ C
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
h✝ : IsEmpty α
⊢ ‖f‖ ≤ C

tactic: exact norm_le_of_forall_le' C hCf
state_before: case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
C : ℝ
hC : 0 ≤ C
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
h✝ : Nonempty α
⊢ ‖f‖ ≤ C
Theorem: isOpenMap_iff_interior
File: Mathlib/Topology/Maps.lean

tactic: rw [hu.interior_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.197449
δ : Type ?u.197452
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
hs : ∀ (s : Set α), f '' interior s ⊆ interior (f '' s)
u : Set α
hu : IsOpen u
⊢ f '' u = f '' interior u
Theorem: PFun.mem_prodMap
File: Mathlib/Data/PFun.lean

tactic: trans ∃ hp hq, (f x.1).get hp = y.1 ∧ (g x.2).get hq = y.2
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type u_4
ε : Type ?u.63784
ι : Type ?u.63787
f✝ : α →. β
f : α →. γ
g : β →. δ
x : α × β
y : γ × δ
⊢ y ∈ prodMap f g x ↔ y.fst ∈ f x.fst ∧ y.snd ∈ g x.snd

tactic: simp only [prodMap, Part.mem_mk_iff, And.exists, Prod.ext_iff]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type u_4
ε : Type ?u.63784
ι : Type ?u.63787
f✝ : α →. β
f : α →. γ
g : β →. δ
x : α × β
y : γ × δ
⊢ y ∈ prodMap f g x ↔ ∃ hp hq, Part.get (f x.fst) hp = y.fst ∧ Part.get (g x.snd) hq = y.snd
Theorem: ProjectiveSpectrum.mem_vanishingIdeal
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: rw [← SetLike.mem_coe, coe_vanishingIdeal, Set.mem_setOf_eq]
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
f : A
⊢ f ∈ vanishingIdeal t ↔ ∀ (x : ProjectiveSpectrum 𝒜), x ∈ t → f ∈ x.asHomogeneousIdeal