tasksource/leandojo huggingface dataset:
Theorem: add_tsub_cancel_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine' le_antisymm _ le_add_tsub
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a + (b - a) = b

tactic: obtain ⟨c, rfl⟩ := exists_add_of_le h
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a + (b - a) ≤ b

tactic: exact add_le_add_left add_tsub_le_left a
state_before: case intro
α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c✝ d c : α
h : a ≤ a + c
⊢ a + (a + c - a) ≤ a + c
Theorem: Associates.FactorSet.sup_add_inf_eq_add
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableEq (Associates α)
b : FactorSet α
⊢ ⊤ ⊔ b + ⊤ ⊓ b = ⊤ + b

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableEq (Associates α)
a : FactorSet α
⊢ a ⊔ ⊤ + a ⊓ ⊤ = a + ⊤

tactic: rw [← WithTop.coe_sup, ← WithTop.coe_inf, ← WithTop.coe_add, ← WithTop.coe_add,
  WithTop.coe_eq_coe]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableEq (Associates α)
a b : Multiset { a // Irreducible a }
⊢ ↑a ⊔ ↑b + ↑a ⊓ ↑b = ↑a + ↑b

tactic: exact Multiset.union_add_inter _ _
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableEq (Associates α)
a b : Multiset { a // Irreducible a }
⊢ a ⊔ b + a ⊓ b = a + b
Theorem: Finset.gcd_image
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: classical induction' s using Finset.induction with c s _ ih <;> simp [*]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s✝ s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
g : γ → β
s : Finset γ
⊢ gcd (image g s) f = gcd s (f ∘ g)

tactic: induction' s using Finset.induction with c s _ ih <;> simp [*]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s✝ s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
g : γ → β
s : Finset γ
⊢ gcd (image g s) f = gcd s (f ∘ g)
Theorem: norm_zpow_le_mul_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rcases n.eq_nat_or_neg with ⟨n, rfl | rfl⟩ <;> simpa using norm_pow_le_mul_norm n a
state_before: 𝓕 : Type ?u.1115291
𝕜 : Type ?u.1115294
α : Type u_1
ι : Type ?u.1115300
κ : Type ?u.1115303
E : Type ?u.1115306
F : Type ?u.1115309
G : Type ?u.1115312
inst✝² : SeminormedCommGroup E
inst✝¹ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : SeminormedCommGroup α
n : ℤ
a : α
⊢ ‖a ^ n‖ ≤ ‖n‖ * ‖a‖
Theorem: Multiset.card_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [e]
state_before: α : Type u_1
β : Type ?u.67658
γ : Type ?u.67661
s : Multiset α
e : s = 0
⊢ ↑card s = 0
Theorem: AddCircle.liftIco_zero_continuous
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: rwa [zero_add]
state_before: 𝕜 : Type u_2
B : Type u_1
inst✝⁴ : LinearOrderedAddCommGroup 𝕜
inst✝³ : TopologicalSpace 𝕜
inst✝² : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝¹ : Archimedean 𝕜
inst✝ : TopologicalSpace B
f : 𝕜 → B
hf : f 0 = f p
hc : ContinuousOn f (Icc 0 p)
⊢ f 0 = f (0 + p)

tactic: rwa [zero_add]
state_before: 𝕜 : Type u_2
B : Type u_1
inst✝⁴ : LinearOrderedAddCommGroup 𝕜
inst✝³ : TopologicalSpace 𝕜
inst✝² : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝¹ : Archimedean 𝕜
inst✝ : TopologicalSpace B
f : 𝕜 → B
hf : f 0 = f p
hc : ContinuousOn f (Icc 0 p)
⊢ ContinuousOn f (Icc 0 (0 + p))
Theorem: Std.RBNode.Ordered.map
File: Std/Data/RBMap/WF.lean

tactic: refine ⟨ax.map ?_, xb.map ?_, ha.map f, hb.map f⟩ <;> exact IsMonotone.lt_mono
state_before: α : Type u_1
β : Type u_2
cmpα : α → α → Ordering
cmpβ : β → β → Ordering
f : α → β
inst✝ : IsMonotone cmpα cmpβ f
c✝ : RBColor
a : RBNode α
x : α
b : RBNode α
ax : All (fun x_1 => cmpLT cmpα x_1 x) a
xb : All (fun x_1 => cmpLT cmpα x x_1) b
ha : Ordered cmpα a
hb : Ordered cmpα b
⊢ Ordered cmpβ (map f (node c✝ a x b))
Theorem: Pi.openSegment_subset
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rintro z ⟨a, b, ha, hb, hab, hz⟩ i -
state_before: 𝕜 : Type u_3
E : Type ?u.380819
F : Type ?u.380822
G : Type ?u.380825
ι : Type u_1
π : ι → Type u_2
inst✝² : OrderedSemiring 𝕜
inst✝¹ : (i : ι) → AddCommMonoid (π i)
inst✝ : (i : ι) → Module 𝕜 (π i)
s : Set ι
x y : (i : ι) → π i
⊢ openSegment 𝕜 x y ⊆ pi s fun i => openSegment 𝕜 (x i) (y i)

tactic: exact ⟨a, b, ha, hb, hab, congr_fun hz i⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_3
E : Type ?u.380819
F : Type ?u.380822
G : Type ?u.380825
ι : Type u_1
π : ι → Type u_2
inst✝² : OrderedSemiring 𝕜
inst✝¹ : (i : ι) → AddCommMonoid (π i)
inst✝ : (i : ι) → Module 𝕜 (π i)
s : Set ι
x y z : (i : ι) → π i
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • x + b • y = z
i : ι
⊢ z i ∈ (fun i => openSegment 𝕜 (x i) (y i)) i
Theorem: HasCompactSupport.mul_left
File: Mathlib/Topology/Support.lean

tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type ?u.31932
α : Type u_1
α' : Type ?u.31938
β : Type u_2
γ : Type ?u.31944
δ : Type ?u.31947
M : Type ?u.31950
E : Type ?u.31953
R : Type ?u.31956
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : HasCompactSupport f'
⊢ HasCompactSupport (f * f')

tactic: refine' hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, mul_zero]
state_before: X : Type ?u.31932
α : Type u_1
α' : Type ?u.31938
β : Type u_2
γ : Type ?u.31944
δ : Type ?u.31947
M : Type ?u.31950
E : Type ?u.31953
R : Type ?u.31956
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f' =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0

tactic: simp_rw [Pi.mul_apply, hx, Pi.zero_apply, mul_zero]
state_before: X : Type ?u.31932
α : Type u_1
α' : Type ?u.31938
β : Type u_2
γ : Type ?u.31944
δ : Type ?u.31947
M : Type ?u.31950
E : Type ?u.31953
R : Type ?u.31956
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x✝ : α
hf : f' =ᶠ[coclosedCompact α] 0
x : α
hx : f' x = OfNat.ofNat 0 x
⊢ (f * f') x = OfNat.ofNat 0 x
Theorem: Real.eq_zero_rpow_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← zero_rpow_eq_iff, eq_comm]
state_before: x a : ℝ
⊢ a = 0 ^ x ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
Theorem: Fin.insertNth_apply_above
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [insertNth, succAboveCases, dif_neg h.ne', dif_neg h.not_lt]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i j : Fin (n + 1)
h : i < j
x : α i
p : (k : Fin n) → α (↑(succAbove i) k)
⊢ insertNth i x p j = Eq.recOn (_ : ↑(succAbove i) (pred j (_ : j ≠ 0)) = j) (p (pred j (_ : j ≠ 0)))
Theorem: BoxIntegral.Box.disjoint_splitCenterBox
File: Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean

tactic: rw [disjoint_iff_inf_le]
state_before: ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
⊢ Disjoint ↑(splitCenterBox I s) ↑(splitCenterBox I t)

tactic: rintro y ⟨hs, ht⟩
state_before: ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
⊢ ↑(splitCenterBox I s) ⊓ ↑(splitCenterBox I t) ≤ ⊥

tactic: apply h
state_before: case intro
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(splitCenterBox I s)
ht : y ∈ ↑(splitCenterBox I t)
⊢ y ∈ ⊥

tactic: ext i
state_before: case intro
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(splitCenterBox I s)
ht : y ∈ ↑(splitCenterBox I t)
⊢ s = t

tactic: rw [mem_coe, mem_splitCenterBox] at hs ht
state_before: case intro.h
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(splitCenterBox I s)
ht : y ∈ ↑(splitCenterBox I t)
i : ι
⊢ i ∈ s ↔ i ∈ t

tactic: rw [← hs.2, ← ht.2]
state_before: case intro.h
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ I ∧ ∀ (i : ι), (lower I i + upper I i) / 2 < y i ↔ i ∈ s
ht : y ∈ I ∧ ∀ (i : ι), (lower I i + upper I i) / 2 < y i ↔ i ∈ t
i : ι
⊢ i ∈ s ↔ i ∈ t
Theorem: Equiv.Perm.IsSwap.isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rintro ⟨x, y, hxy, rfl⟩
state_before: ι : Type ?u.418035
α : Type u_1
β : Type ?u.418041
f g : Perm α
x y : α
inst✝ : DecidableEq α
⊢ IsSwap f → IsCycle f

tactic: exact isCycle_swap hxy
state_before: case intro.intro.intro
ι : Type ?u.418035
α : Type u_1
β : Type ?u.418041
g : Perm α
x✝ y✝ : α
inst✝ : DecidableEq α
x y : α
hxy : x ≠ y
⊢ IsCycle (swap x y)
Theorem: AddMonoidAlgebra.prod_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [prod_cons has, ih, single_mul_single, sum_cons has, prod_cons has]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.2771476
ι : Type ui
inst✝¹ : CommSemiring k
inst✝ : AddCommMonoid G
s✝ : Finset ι
a✝ : ι → G
b : ι → k
a : ι
s : Finset ι
has : ¬a ∈ s
ih : ∏ i in s, single (a✝ i) (b i) = single (∑ i in s, a✝ i) (∏ i in s, b i)
⊢ ∏ i in cons a s has, single (a✝ i) (b i) = single (∑ i in cons a s has, a✝ i) (∏ i in cons a s has, b i)
Theorem: MeasurableSet.image_of_measurable_injOn
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: obtain ⟨t', t't, f_cont, t'_polish⟩ :
  ∃ t' : TopologicalSpace γ, t' ≤ tγ ∧ @Continuous γ β t' tβ f ∧ @PolishSpace γ t' :=
  f_meas.exists_continuous
state_before: α : Type ?u.322100
inst✝⁶ : TopologicalSpace α
ι : Type ?u.322106
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁵ : PolishSpace γ
inst✝⁴ : MeasurableSpace γ
hγb : BorelSpace γ
β : Type u_1
tβ : TopologicalSpace β
inst✝³ : T2Space β
inst✝² : MeasurableSpace β
inst✝¹ : BorelSpace β
s : Set γ
f : γ → β
inst✝ : SecondCountableTopology β
hs : MeasurableSet s
f_meas : Measurable f
f_inj : InjOn f s
⊢ MeasurableSet (f '' s)

tactic: have M : MeasurableSet[@borel γ t'] s :=
  @Continuous.measurable γ γ t' (@borel γ t')
    (@BorelSpace.opensMeasurable γ t' (@borel γ t') (@BorelSpace.mk _ _ (borel γ) rfl))
    tγ _ _ _ (continuous_id_of_le t't) s hs
state_before: case intro.intro.intro
α : Type ?u.322100
inst✝⁶ : TopologicalSpace α
ι : Type ?u.322106
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁵ : PolishSpace γ
inst✝⁴ : MeasurableSpace γ
hγb : BorelSpace γ
β : Type u_1
tβ : TopologicalSpace β
inst✝³ : T2Space β
inst✝² : MeasurableSpace β
inst✝¹ : BorelSpace β
s : Set γ
f : γ → β
inst✝ : SecondCountableTopology β
hs : MeasurableSet s
f_meas : Measurable f
f_inj : InjOn f s
t' : TopologicalSpace γ
t't : t' ≤ tγ
f_cont : Continuous f
t'_polish : PolishSpace γ
⊢ MeasurableSet (f '' s)

tactic: exact
  @MeasurableSet.image_of_continuousOn_injOn γ t' t'_polish (@borel γ t')
    (@BorelSpace.mk _ _ (borel γ) rfl)
    β _ _ _ _ s f M (@Continuous.continuousOn γ β t' tβ f s f_cont) f_inj
state_before: case intro.intro.intro
α : Type ?u.322100
inst✝⁶ : TopologicalSpace α
ι : Type ?u.322106
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁵ : PolishSpace γ
inst✝⁴ : MeasurableSpace γ
hγb : BorelSpace γ
β : Type u_1
tβ : TopologicalSpace β
inst✝³ : T2Space β
inst✝² : MeasurableSpace β
inst✝¹ : BorelSpace β
s : Set γ
f : γ → β
inst✝ : SecondCountableTopology β
hs : MeasurableSet s
f_meas : Measurable f
f_inj : InjOn f s
t' : TopologicalSpace γ
t't : t' ≤ tγ
f_cont : Continuous f
t'_polish : PolishSpace γ
M : MeasurableSet s
⊢ MeasurableSet (f '' s)
Theorem: inv_mul_le_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [inv_eq_one_div, mul_comm, ← div_eq_mul_one_div]
state_before: ι : Type ?u.30788
α : Type u_1
β : Type ?u.30794
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ b⁻¹ * a ≤ c ↔ a ≤ b * c

tactic: exact div_le_iff' h
state_before: ι : Type ?u.30788
α : Type u_1
β : Type ?u.30794
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a / b ≤ c ↔ a ≤ b * c
Theorem: Order.sequenceOfCofinals.monotone
File: Mathlib/Order/Ideal.lean

tactic: apply monotone_nat_of_le_succ
state_before: P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
⊢ Monotone (sequenceOfCofinals p 𝒟)

tactic: intro n
state_before: case hf
P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
⊢ ∀ (n : ℕ), sequenceOfCofinals p 𝒟 n ≤ sequenceOfCofinals p 𝒟 (n + 1)

tactic: dsimp only [sequenceOfCofinals, Nat.add]
state_before: case hf
P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
n : ℕ
⊢ sequenceOfCofinals p 𝒟 n ≤ sequenceOfCofinals p 𝒟 (n + 1)

tactic: cases (Encodable.decode n : Option ι)
state_before: case hf
P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
n : ℕ
⊢ sequenceOfCofinals p 𝒟 n ≤
    match Encodable.decode n with
    | none => sequenceOfCofinals p 𝒟 n
    | some i => Cofinal.above (𝒟 i) (sequenceOfCofinals p 𝒟 n)

tactic: rfl
state_before: case hf.none
P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
n : ℕ
⊢ sequenceOfCofinals p 𝒟 n ≤
    match none with
    | none => sequenceOfCofinals p 𝒟 n
    | some i => Cofinal.above (𝒟 i) (sequenceOfCofinals p 𝒟 n)

tactic: apply Cofinal.le_above
state_before: case hf.some
P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
n : ℕ
val✝ : ι
⊢ sequenceOfCofinals p 𝒟 n ≤
    match some val✝ with
    | none => sequenceOfCofinals p 𝒟 n
    | some i => Cofinal.above (𝒟 i) (sequenceOfCofinals p 𝒟 n)
Theorem: CategoryTheory.Functor.coreprW_app_hom
File: Mathlib/CategoryTheory/Yoneda.lean

tactic: change F.coreprF.app X f = (F.coreprF.app F.coreprX ≫ F.map f) (𝟙 F.coreprX)
state_before: C : Type u₁
inst✝¹ : Category C
F : C ⥤ Type v₁
inst✝ : Corepresentable F
X : C
f : coreprX F ⟶ X
⊢ ((coreprW F).app X).hom f = F.map f (coreprx F)

tactic: rw [← F.coreprF.naturality]
state_before: C : Type u₁
inst✝¹ : Category C
F : C ⥤ Type v₁
inst✝ : Corepresentable F
X : C
f : coreprX F ⟶ X
⊢ (coreprF F).app X f = ((coreprF F).app (coreprX F) ≫ F.map f) (𝟙 (coreprX F))

tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category C
F : C ⥤ Type v₁
inst✝ : Corepresentable F
X : C
f : coreprX F ⟶ X
⊢ (coreprF F).app X f = ((coyoneda.obj (coreprX F).op).map f ≫ (coreprF F).app X) (𝟙 (coreprX F))

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
F : C ⥤ Type v₁
inst✝ : Corepresentable F
X : C
f : coreprX F ⟶ X
⊢ (coreprF F).app X f = (coreprF F).app X (𝟙 (coreprX F) ≫ f)
Theorem: TensorAlgebra.lift_comp_ι
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

tactic: rw [← lift_symm_apply]
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
g : TensorAlgebra R M →ₐ[R] A
⊢ ↑(lift R) (LinearMap.comp (AlgHom.toLinearMap g) (ι R)) = g

tactic: exact (lift R).apply_symm_apply g
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
g : TensorAlgebra R M →ₐ[R] A
⊢ ↑(lift R) (↑(lift R).symm g) = g
Theorem: CauSeq.lim_add
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: rw [const_add, add_sub_add_comm]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ LimZero (const abv (lim f + lim g) - (f + g))

tactic: exact add_limZero (Setoid.symm (equiv_lim f)) (Setoid.symm (equiv_lim g))
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ LimZero (const abv (lim f) - f + (const abv (lim g) - g))
Theorem: Real.sq_le
File: Mathlib/Data/Real/Sqrt.lean

tactic: constructor
state_before: x y : ℝ
h : 0 ≤ y
⊢ x ^ 2 ≤ y ↔ -sqrt y ≤ x ∧ x ≤ sqrt y

tactic: simpa only [abs_le] using abs_le_sqrt
state_before: case mp
x y : ℝ
h : 0 ≤ y
⊢ x ^ 2 ≤ y → -sqrt y ≤ x ∧ x ≤ sqrt y

tactic: rw [← abs_le, ← sq_abs]
state_before: case mpr
x y : ℝ
h : 0 ≤ y
⊢ -sqrt y ≤ x ∧ x ≤ sqrt y → x ^ 2 ≤ y

tactic: exact (le_sqrt (abs_nonneg x) h).mp
state_before: case mpr
x y : ℝ
h : 0 ≤ y
⊢ abs x ≤ sqrt y → abs x ^ 2 ≤ y
Theorem: Ordinal.nfpFamily_le_fp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: by_cases hι : IsEmpty ι
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
⊢ List.foldr f a l ≤ b

tactic: rwa [Unique.eq_default l]
state_before: case pos
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : IsEmpty ι
⊢ List.foldr f a l ≤ b

tactic: induction' l with i l IH generalizing a
state_before: case neg
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : ¬IsEmpty ι
⊢ List.foldr f a l ≤ b

tactic: exact (H i (IH ab)).trans (h i)
state_before: case neg.cons
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), Monotone (f i)
a✝ b : Ordinal
ab✝ : a✝ ≤ b
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
i : ι
l : List ι
IH : ∀ {a : Ordinal}, a ≤ b → List.foldr f a l ≤ b
a : Ordinal
ab : a ≤ b
⊢ List.foldr f a (i :: l) ≤ b

tactic: exact ab
state_before: case neg.nil
ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), Monotone (f i)
a✝ b : Ordinal
ab✝ : a✝ ≤ b
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
a : Ordinal
ab : a ≤ b
⊢ List.foldr f a [] ≤ b
Theorem: Metric.infEdist_eq_top_iff
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases s.eq_empty_or_nonempty with rfl | hs <;> simp [*, Nonempty.ne_empty, infEdist_ne_top]
state_before: ι : Sort ?u.58413
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infEdist x s = ⊤ ↔ s = ∅
Theorem: NonUnitalRingHom.zero_comp
File: Mathlib/Algebra/Hom/Ring.lean

tactic: ext
state_before: F : Type ?u.34956
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g : β →ₙ+* γ
f✝ f : α →ₙ+* β
⊢ comp 0 f = 0

tactic: rfl
state_before: case a
F : Type ?u.34956
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g : β →ₙ+* γ
f✝ f : α →ₙ+* β
x✝ : α
⊢ ↑(comp 0 f) x✝ = ↑0 x✝
Theorem: Nat.totient_eq_div_factors_mul
File: Mathlib/Data/Nat/Totient.lean

tactic: rw [← mul_div_left n.totient, totient_mul_prod_factors, mul_comm,
  Nat.mul_div_assoc _ (prod_prime_factors_dvd n), mul_comm]
state_before: n : ℕ
⊢ φ n = (n / ∏ p in List.toFinset (factors n), p) * ∏ p in List.toFinset (factors n), (p - 1)

tactic: have := prod_pos (fun p => pos_of_mem_factorization (n := n))
state_before: n : ℕ
⊢ 0 < ∏ p in List.toFinset (factors n), p

tactic: simpa [prod_factorization_eq_prod_factors] using this
state_before: n : ℕ
this : 0 < ∏ i in (factorization n).support, i
⊢ 0 < ∏ p in List.toFinset (factors n), p
Theorem: Function.Antiperiodic.add
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all [← add_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.205812
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Antiperiodic f c₁
h2 : Antiperiodic f c₂
⊢ Periodic f (c₁ + c₂)
Theorem: neg_one_pow_mul_eq_zero_iff
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: rcases neg_one_pow_eq_or R n with h | h <;> simp [h]
state_before: R : Type u_1
S : Type ?u.118788
M : Type ?u.118791
inst✝ : Ring R
a b : R
n : ℕ
r : R
⊢ (-1) ^ n * r = 0 ↔ r = 0
Theorem: Complex.continuousAt_cpow_zero_of_re_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: have hz₀ : z ≠ 0 := ne_of_apply_ne re hz.ne'
state_before: z : ℂ
hz : 0 < z.re
⊢ ContinuousAt (fun x => x.fst ^ x.snd) (0, z)

tactic: rw [ContinuousAt, zero_cpow hz₀, tendsto_zero_iff_norm_tendsto_zero]
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ ContinuousAt (fun x => x.fst ^ x.snd) (0, z)

tactic: refine' squeeze_zero (fun _ => norm_nonneg _) (fun _ => abs_cpow_le _ _) _
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun e => ‖e.fst ^ e.snd‖) (𝓝 (0, z)) (𝓝 0)

tactic: simp only [div_eq_mul_inv, ← Real.exp_neg]
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => ↑abs x.fst ^ x.snd.re / Real.exp (arg x.fst * x.snd.im)) (𝓝 (0, z)) (𝓝 0)

tactic: refine' Tendsto.zero_mul_isBoundedUnder_le _ _
state_before: z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => ↑abs x.fst ^ x.snd.re * Real.exp (-(arg x.fst * x.snd.im))) (𝓝 (0, z)) (𝓝 0)

tactic: convert
    (continuous_fst.norm.tendsto ((0 : ℂ), z)).rpow
      ((continuous_re.comp continuous_snd).tendsto _) _ <;>
  simp [hz, Real.zero_rpow hz.ne']
state_before: case refine'_1
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ Tendsto (fun x => ↑abs x.fst ^ x.snd.re) (𝓝 (0, z)) (𝓝 0)

tactic: simp only [Function.comp, Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)]
state_before: case refine'_2
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) ((fun x => ‖x‖) ∘ fun x => Real.exp (-(arg x.fst * x.snd.im)))

tactic: rcases exists_gt (|im z|) with ⟨C, hC⟩
state_before: case refine'_2
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) fun x => Real.exp (-(arg x.fst * x.snd.im))

tactic: refine' ⟨Real.exp (π * C), eventually_map.2 _⟩
state_before: case refine'_2.intro
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
C : ℝ
hC : Abs.abs z.im < C
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (𝓝 (0, z)) fun x => Real.exp (-(arg x.fst * x.snd.im))

tactic: refine'
  (((continuous_im.comp continuous_snd).abs.tendsto (_, z)).eventually (gt_mem_nhds hC)).mono
    fun z hz => Real.exp_le_exp.2 <| (neg_le_abs_self _).trans _
state_before: case refine'_2.intro
z : ℂ
hz : 0 < z.re
hz₀ : z ≠ 0
C : ℝ
hC : Abs.abs z.im < C
⊢ ∀ᶠ (a : ℂ × ℂ) in 𝓝 (0, z), (fun x x_1 => x ≤ x_1) (Real.exp (-(arg a.fst * a.snd.im))) (Real.exp (π * C))

tactic: rw [_root_.abs_mul]
state_before: case refine'_2.intro
z✝ : ℂ
hz✝ : 0 < z✝.re
hz₀ : z✝ ≠ 0
C : ℝ
hC : Abs.abs z✝.im < C
z : ℂ × ℂ
hz : Abs.abs ((im ∘ Prod.snd) z) < C
⊢ Abs.abs (arg z.fst * z.snd.im) ≤ π * C

tactic: exact
  mul_le_mul (abs_le.2 ⟨(neg_pi_lt_arg _).le, arg_le_pi _⟩) hz.le (_root_.abs_nonneg _)
    Real.pi_pos.le
state_before: case refine'_2.intro
z✝ : ℂ
hz✝ : 0 < z✝.re
hz₀ : z✝ ≠ 0
C : ℝ
hC : Abs.abs z✝.im < C
z : ℂ × ℂ
hz : Abs.abs ((im ∘ Prod.snd) z) < C
⊢ Abs.abs (arg z.fst) * Abs.abs z.snd.im ≤ π * C