tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Box.splitUpper_eq_bot
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: rw [splitUpper, mk'_eq_bot, exists_update_iff I.lower fun j y => I.upper j ≤ y]
state_before: ι : Type u_1
M : Type ?u.13653
n : ℕ
I : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
i : ι
x : ℝ
⊢ splitUpper I i x = ⊥ ↔ upper I i ≤ x

tactic: simp [(I.lower_lt_upper _).not_le]
state_before: ι : Type u_1
M : Type ?u.13653
n : ℕ
I : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
i : ι
x : ℝ
⊢ (upper I i ≤ max x (lower I i) ∨ ∃ x x_1, upper I x ≤ lower I x) ↔ upper I i ≤ x
Theorem: InnerProductGeometry.IsConformalMap.preserves_angle
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Conformal.lean

tactic: obtain ⟨c, hc, li, rfl⟩ := h
state_before: E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace ℝ E
inst✝ : InnerProductSpace ℝ F
f' : E →L[ℝ] F
h : IsConformalMap f'
u v : E
⊢ angle (↑f' u) (↑f' v) = angle u v

tactic: exact (angle_smul_smul hc _ _).trans (li.angle_map _ _)
state_before: case intro.intro.intro
E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace ℝ E
inst✝ : InnerProductSpace ℝ F
u v : E
c : ℝ
hc : c ≠ 0
li : E →ₗᵢ[ℝ] F
⊢ angle (↑(c • LinearIsometry.toContinuousLinearMap li) u) (↑(c • LinearIsometry.toContinuousLinearMap li) v) =
    angle u v
Theorem: Coheyting.boundary_top
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, hnot_top, inf_bot_eq]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ ⊤ = ⊥
Theorem: ContDiffAt.add
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1726488
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f g : E → F
hf : ContDiffAt 𝕜 n f x
hg : ContDiffAt 𝕜 n g x
⊢ ContDiffAt 𝕜 n (fun x => f x + g x) x

tactic: exact hf.add hg
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1726488
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f g : E → F
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x + g x) univ x
Theorem: isRadical_iff_span_singleton
File: Mathlib/RingTheory/Nilpotent.lean

tactic: simp_rw [IsRadical, ← Ideal.mem_span_singleton]
state_before: R S : Type u
x y : R
inst✝ : CommSemiring R
⊢ IsRadical y ↔ Ideal.IsRadical (Ideal.span {y})

tactic: exact forall_swap.trans (forall_congr' fun r => exists_imp.symm)
state_before: R S : Type u
x y : R
inst✝ : CommSemiring R
⊢ (∀ (n : ℕ) (x : R), x ^ n ∈ Ideal.span {y} → x ∈ Ideal.span {y}) ↔ Ideal.IsRadical (Ideal.span {y})
Theorem: mul_eq_of_eq_mul_inv
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type ?u.52587
β : Type ?u.52590
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = c * b⁻¹
⊢ a * b = c
Theorem: sInf_within_of_ordConnected
File: Mathlib/Order/CompleteLatticeIntervals.lean

tactic: obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
state_before: α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
ht : Set.Nonempty t
h_bdd : BddBelow t
⊢ sInf (Subtype.val '' t) ∈ s

tactic: obtain ⟨B, hB⟩ : ∃ B, B ∈ lowerBounds t := h_bdd
state_before: case intro
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
h_bdd : BddBelow t
c : ↑s
hct : c ∈ t
⊢ sInf (Subtype.val '' t) ∈ s

tactic: refine' hs.out B.2 c.2 ⟨_, _⟩
state_before: case intro.intro
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ sInf (Subtype.val '' t) ∈ s

tactic: exact (Subtype.mono_coe s).le_csInf_image ⟨c, hct⟩ hB
state_before: case intro.intro.refine'_1
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ ↑B ≤ sInf (Subtype.val '' t)

tactic: exact (Subtype.mono_coe s).csInf_image_le hct ⟨B, hB⟩
state_before: case intro.intro.refine'_2
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ sInf (Subtype.val '' t) ≤ ↑c
Theorem: SimplexCategory.eq_σ_of_epi
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: rcases eq_σ_comp_of_not_injective θ (by
  by_contra h
  simpa using le_of_mono (mono_iff_injective.mpr h)) with ⟨i, θ', h⟩
state_before: n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
⊢ ∃ i, θ = σ i

tactic: use i
state_before: case intro.intro
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ ∃ i, θ = σ i

tactic: haveI : Epi (σ i ≫ θ') := by
  rw [← h]
  infer_instance
state_before: case intro.intro
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ θ = σ i

tactic: haveI := CategoryTheory.epi_of_epi (σ i) θ'
state_before: case intro.intro
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
this : Epi (σ i ≫ θ')
⊢ θ = σ i

tactic: rw [h, eq_id_of_epi θ', Category.comp_id]
state_before: case intro.intro
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
this✝ : Epi (σ i ≫ θ')
this : Epi θ'
⊢ θ = σ i

tactic: by_contra h
state_before: n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
⊢ ¬Function.Injective ↑(Hom.toOrderHom θ)

tactic: simpa using le_of_mono (mono_iff_injective.mpr h)
state_before: n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
h : Function.Injective ↑(Hom.toOrderHom θ)
⊢ False

tactic: rw [← h]
state_before: n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ Epi (σ i ≫ θ')

tactic: infer_instance
state_before: n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ Epi θ
Theorem: Equiv.Perm.cycleOf_zpow_apply_self
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: intro z
state_before: ι : Type ?u.2180524
α : Type u_1
β : Type ?u.2180530
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
⊢ ∀ (n : ℤ), ↑(cycleOf f x ^ n) x = ↑(f ^ n) x

tactic: induction' z with z hz
state_before: ι : Type ?u.2180524
α : Type u_1
β : Type ?u.2180530
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
z : ℤ
⊢ ↑(cycleOf f x ^ z) x = ↑(f ^ z) x

tactic: exact cycleOf_pow_apply_self f x z
state_before: case ofNat
ι : Type ?u.2180524
α : Type u_1
β : Type ?u.2180530
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
z : ℕ
⊢ ↑(cycleOf f x ^ Int.ofNat z) x = ↑(f ^ Int.ofNat z) x

tactic: rw [zpow_negSucc, ← inv_pow, cycleOf_inv, zpow_negSucc, ← inv_pow, cycleOf_pow_apply_self]
state_before: case negSucc
ι : Type ?u.2180524
α : Type u_1
β : Type ?u.2180530
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
hz : ℕ
⊢ ↑(cycleOf f x ^ Int.negSucc hz) x = ↑(f ^ Int.negSucc hz) x
Theorem: Dfinsupp.filter_apply_pos
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [filter_apply, if_pos h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
h : p i
⊢ ↑(filter p f) i = ↑f i
Theorem: Finmap.lookup_singleton_eq
File: Mathlib/Data/Finmap.lean

tactic: rw [singleton, lookup_toFinmap, AList.singleton, AList.lookup, dlookup_cons_eq]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
⊢ lookup a (singleton a b) = some b
Theorem: PFunctor.iget_map
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: simp only [Obj.iget, fst_map, *, dif_pos, eq_self_iff_true]
state_before: P : PFunctor
α✝ β✝ : Type u
inst✝² : DecidableEq P.A
α β : Type u
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : Obj P α
f : α → β
i : IdxCat P
h : i.fst = x.fst
⊢ Obj.iget (f <$> x) i = f (Obj.iget x i)

tactic: cases x
state_before: P : PFunctor
α✝ β✝ : Type u
inst✝² : DecidableEq P.A
α β : Type u
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : Obj P α
f : α → β
i : IdxCat P
h : i.fst = x.fst
⊢ Sigma.snd (f <$> x) (cast (_ : B P i.fst = B P (f <$> x).fst) i.snd) =
    f (Sigma.snd x (cast (_ : B P i.fst = B P x.fst) i.snd))

tactic: rfl
state_before: case mk
P : PFunctor
α✝ β✝ : Type u
inst✝² : DecidableEq P.A
α β : Type u
inst✝¹ : Inhabited α
inst✝ : Inhabited β
f : α → β
i : IdxCat P
fst✝ : P.A
snd✝ : B P fst✝ → α
h : i.fst = { fst := fst✝, snd := snd✝ }.fst
⊢ Sigma.snd (f <$> { fst := fst✝, snd := snd✝ })
      (cast (_ : B P i.fst = B P (f <$> { fst := fst✝, snd := snd✝ }).fst) i.snd) =
    f (Sigma.snd { fst := fst✝, snd := snd✝ } (cast (_ : B P i.fst = B P { fst := fst✝, snd := snd✝ }.fst) i.snd))
Theorem: HomologicalComplex.d_comp_eqToHom
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: obtain rfl := c.next_eq rij rij'
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j j' : ι
rij : ComplexShape.Rel c i j
rij' : ComplexShape.Rel c i j'
⊢ d C i j' ≫ eqToHom (_ : X C j' = X C j) = d C i j

tactic: simp only [eqToHom_refl, comp_id]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
rij rij' : ComplexShape.Rel c i j
⊢ d C i j ≫ eqToHom (_ : X C j = X C j) = d C i j
Theorem: Membership.mem.upper
File: src/lean/Init/Data/Range.lean

tactic: simp [Membership.mem] at h
state_before: i : Nat
r : Std.Range
h : i ∈ r
⊢ i < r.stop

tactic: exact h.2
state_before: i : Nat
r : Std.Range
h : r.start ≤ i ∧ i < r.stop
⊢ i < r.stop
Theorem: Int.ModEq.mul_right'
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [mul_comm a, mul_comm b, mul_comm n]
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ a * c ≡ b * c [ZMOD n * c]

tactic: exact h.mul_left'
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ c * a ≡ c * b [ZMOD c * n]
Theorem: CategoryTheory.Limits.eq_zero_of_image_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [← image.fac f, w, HasZeroMorphisms.comp_zero]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasImage f
w : image.ι f = 0
⊢ f = 0
Theorem: SimpleGraph.Walk.coe_support
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ ↑(support p) = {u} + ↑(List.tail (support p))
Theorem: exists_eq_pow_of_mul_eq_pow_of_coprime
File: Mathlib/RingTheory/IntegralDomain.lean

tactic: refine' exists_eq_pow_of_mul_eq_pow (isUnit_of_dvd_one _) h
state_before: M : Type ?u.9200
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_1
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
cp : IsCoprime a b
h : a * b = c ^ n
⊢ ∃ d, a = d ^ n

tactic: obtain ⟨x, y, hxy⟩ := cp
state_before: M : Type ?u.9200
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_1
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
cp : IsCoprime a b
h : a * b = c ^ n
⊢ GCDMonoid.gcd a b ∣ 1

tactic: rw [← hxy]
state_before: case intro.intro
M : Type ?u.9200
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_1
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
h : a * b = c ^ n
x y : R
hxy : x * a + y * b = 1
⊢ GCDMonoid.gcd a b ∣ 1

tactic: exact  dvd_add (dvd_mul_of_dvd_right (GCDMonoid.gcd_dvd_left _ _) _)
    (dvd_mul_of_dvd_right (GCDMonoid.gcd_dvd_right _ _) _)
state_before: case intro.intro
M : Type ?u.9200
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_1
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
h : a * b = c ^ n
x y : R
hxy : x * a + y * b = 1
⊢ GCDMonoid.gcd a b ∣ x * a + y * b
Theorem: Option.map_injective'
File: Mathlib/Data/Option/Basic.lean

tactic: simp only [← map_some', h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3918
δ : Type ?u.3921
f g : α → β
h : Option.map f = Option.map g
x : α
⊢ some (f x) = some (g x)
Theorem: bihimp_bihimp_self
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp_comm, bihimp_bihimp_cancel_left]
state_before: ι : Type ?u.82995
α : Type u_1
β : Type ?u.83001
π : ι → Type ?u.83006
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ b ⇔ a = b
Theorem: UniqueFactorizationMonoid.exists_mem_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: obtain ⟨p', hp', hp'x⟩ := WfDvdMonoid.exists_irreducible_factor h hx
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
⊢ ∃ p, p ∈ factors x

tactic: obtain ⟨p, hp, _⟩ := exists_mem_factors_of_dvd hx hp' hp'x
state_before: case intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ factors x

tactic: exact ⟨p, hp⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ factors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ factors x
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.of_P
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

tactic: exfalso
state_before: C : Type u_1
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
j : Fin (n + 1)
hj₁ : n + 1 ≤ ↑j + 0
⊢ HomologicalComplex.Hom.f (P 0) (n + 1) ≫ δ X (Fin.succ j) = 0

tactic: have hj₂ := Fin.is_lt j
state_before: case h
C : Type u_1
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
j : Fin (n + 1)
hj₁ : n + 1 ≤ ↑j + 0
⊢ False

tactic: linarith
state_before: case h
C : Type u_1
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
j : Fin (n + 1)
hj₁ : n + 1 ≤ ↑j + 0
hj₂ : ↑j < n + 1
⊢ False

tactic: simp only [P_succ]
state_before: C : Type u_1
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ HigherFacesVanish (q + 1) (HomologicalComplex.Hom.f (P (q + 1)) (n + 1))

tactic: exact (of_P q n).induction
state_before: C : Type u_1
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ HigherFacesVanish (q + 1) (HomologicalComplex.Hom.f (P q ≫ (𝟙 K[X] + Hσ q)) (n + 1))
Theorem: tendsto_const_mul_pow_nhds_iff'
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: 𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

tactic: rcases lt_trichotomy c 0 with (hc | rfl | hc)
state_before: case inr
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

tactic: simp [tendsto_const_nhds_iff]
state_before: case inl
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
c d : 𝕜
⊢ Tendsto (fun x => c * x ^ 0) atTop (𝓝 d) ↔ (c = 0 ∨ 0 = 0) ∧ c = d

tactic: have := tendsto_const_mul_pow_atBot_iff.2 ⟨hn, hc⟩
state_before: case inr.inl
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
hc : c < 0
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

tactic: simp [not_tendsto_nhds_of_tendsto_atBot this, hc.ne, hn]
state_before: case inr.inl
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
hc : c < 0
this : Tendsto (fun x => c * x ^ n) atTop atBot
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

tactic: simp [tendsto_const_nhds_iff]
state_before: case inr.inr.inl
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
d : 𝕜
hn : n ≠ 0
⊢ Tendsto (fun x => 0 * x ^ n) atTop (𝓝 d) ↔ (0 = 0 ∨ n = 0) ∧ 0 = d

tactic: have := tendsto_const_mul_pow_atTop_iff.2 ⟨hn, hc⟩
state_before: case inr.inr.inr
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
hc : 0 < c
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d

tactic: simp [not_tendsto_nhds_of_tendsto_atTop this, hc.ne', hn]
state_before: case inr.inr.inr
𝕜 : Type u_1
α : Type ?u.36297
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
c d : 𝕜
hn : n ≠ 0
hc : 0 < c
this : Tendsto (fun x => c * x ^ n) atTop atTop
⊢ Tendsto (fun x => c * x ^ n) atTop (𝓝 d) ↔ (c = 0 ∨ n = 0) ∧ c = d
Theorem: Ordinal.nfp_mul_zero
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← Ordinal.le_zero, nfp_le_iff]
state_before: a : Ordinal
⊢ nfp (fun x => a * x) 0 = 0

tactic: intro n
state_before: a : Ordinal
⊢ ∀ (n : ℕ), ((fun x => a * x)^[n]) 0 ≤ 0

tactic: induction' n with n hn
state_before: a : Ordinal
n : ℕ
⊢ ((fun x => a * x)^[n]) 0 ≤ 0

tactic: dsimp only
state_before: case succ
a : Ordinal
n : ℕ
hn : ((fun x => a * x)^[n]) 0 ≤ 0
⊢ ((fun x => a * x)^[Nat.succ n]) 0 ≤ 0

tactic: rwa [iterate_succ_apply, mul_zero]
state_before: case succ
a : Ordinal
n : ℕ
hn : ((fun x => a * x)^[n]) 0 ≤ 0
⊢ ((fun x => a * x)^[Nat.succ n]) 0 ≤ 0

tactic: rfl
state_before: case zero
a : Ordinal
⊢ ((fun x => a * x)^[Nat.zero]) 0 ≤ 0
Theorem: Int.Prime.dvd_mul
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rwa [← hp.dvd_mul, ← Int.natAbs_mul, ←Int.coe_nat_dvd_left]
state_before: m n : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ m * n
⊢ p ∣ natAbs m ∨ p ∣ natAbs n
Theorem: FreeLieAlgebra.lift_of_apply
File: Mathlib/Algebra/Lie/Free.lean

tactic: rw [← @Function.comp_apply  _ _ _ (lift R f) (of R) x, of_comp_lift]
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x : X
⊢ ↑(↑(lift R) f) (of R x) = f x
Theorem: LinearMap.rank_comp_le_left
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: refine' rank_le_of_submodule _ _ _
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1108176
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ rank (comp f g) ≤ rank f

tactic: rw [LinearMap.range_comp]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1108176
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ range (comp f g) ≤ range f

tactic: exact LinearMap.map_le_range
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1108176
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ Submodule.map f (range g) ≤ range f
Theorem: Ordinal.blsub_eq_blsub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [blsub_eq_lsub', blsub_eq_lsub']
state_before: α : Type ?u.349286
β : Type ?u.349289
γ : Type ?u.349292
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r r' : ι → ι → Prop
inst✝¹ : IsWellOrder ι r
inst✝ : IsWellOrder ι r'
f : ι → Ordinal
⊢ blsub (type r) (bfamilyOfFamily' r f) = blsub (type r') (bfamilyOfFamily' r' f)
Theorem: MeasureTheory.OuterMeasure.map_ofFunction
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: refine' (map_ofFunction_le _).antisymm fun s => _
state_before: α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
⊢ ↑(map f) (OuterMeasure.ofFunction m m_empty) = OuterMeasure.ofFunction (fun s => m (f ⁻¹' s)) m_empty

tactic: simp only [ofFunction_apply, map_apply, le_iInf_iff]
state_before: α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
⊢ ↑(OuterMeasure.ofFunction (fun s => m (f ⁻¹' s)) m_empty) s ≤ ↑(↑(map f) (OuterMeasure.ofFunction m m_empty)) s

tactic: intro t ht
state_before: α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
⊢ ∀ (i : ℕ → Set α),
    f ⁻¹' s ⊆ iUnion i → (⨅ (t : ℕ → Set β) (_ : s ⊆ iUnion t), ∑' (n : ℕ), m (f ⁻¹' t n)) ≤ ∑' (n : ℕ), m (i n)

tactic: refine' iInf_le_of_le (fun n => range fᶜ ∪ f '' t n) (iInf_le_of_le _ _)
state_before: α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
t : ℕ → Set α
ht : f ⁻¹' s ⊆ iUnion t
⊢ (⨅ (t : ℕ → Set β) (_ : s ⊆ iUnion t), ∑' (n : ℕ), m (f ⁻¹' t n)) ≤ ∑' (n : ℕ), m (t n)

tactic: rw [← union_iUnion, ← inter_subset, ← image_preimage_eq_inter_range, ← image_iUnion]
state_before: case refine'_1
α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
t : ℕ → Set α
ht : f ⁻¹' s ⊆ iUnion t
⊢ s ⊆ ⋃ (n : ℕ), range fᶜ ∪ f '' t n

tactic: exact image_subset _ ht
state_before: case refine'_1
α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
t : ℕ → Set α
ht : f ⁻¹' s ⊆ iUnion t
⊢ f '' (f ⁻¹' s) ⊆ f '' ⋃ (i : ℕ), t i

tactic: refine' ENNReal.tsum_le_tsum fun n => le_of_eq _
state_before: case refine'_2
α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
t : ℕ → Set α
ht : f ⁻¹' s ⊆ iUnion t
⊢ (∑' (n : ℕ), m (f ⁻¹' (fun n => range fᶜ ∪ f '' t n) n)) ≤ ∑' (n : ℕ), m (t n)

tactic: simp [hf.preimage_image]
state_before: case refine'_2
α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
hf : Injective f
s : Set β
t : ℕ → Set α
ht : f ⁻¹' s ⊆ iUnion t
n : ℕ
⊢ m (f ⁻¹' (fun n => range fᶜ ∪ f '' t n) n) = m (t n)
Theorem: Nat.size_eq_zero
File: Mathlib/Data/Nat/Size.lean

tactic: have := @size_pos n
state_before: n : ℕ
⊢ size n = 0 ↔ n = 0

tactic: simp [pos_iff_ne_zero] at this
state_before: n : ℕ
this : 0 < size n ↔ 0 < n
⊢ size n = 0 ↔ n = 0

tactic: exact Decidable.not_iff_not.1 this
state_before: n : ℕ
this : ¬size n = 0 ↔ ¬n = 0
⊢ size n = 0 ↔ n = 0
Theorem: RatFunc.mk_coe_def
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp only [mk_eq_div', ← Localization.mk_eq_mk', FractionRing.mk_eq_div]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p : K[X]
q : { x // x ∈ K[X]⁰ }
⊢ RatFunc.mk p ↑q = { toFractionRing := IsLocalization.mk' (FractionRing K[X]) p q }