tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.sum_add_sum
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.347212
γ : Type ?u.347215
δ : Type ?u.347218
ι : Type ?u.347221
R : Type ?u.347224
R' : Type ?u.347227
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν✝ ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ ν : ℕ → Measure α
⊢ sum μ + sum ν = sum fun n => μ n + ν n

tactic: simp only [add_apply, sum_apply _ hs, Pi.add_apply, coe_add,
  tsum_add ENNReal.summable ENNReal.summable]
state_before: case h
α : Type u_1
β : Type ?u.347212
γ : Type ?u.347215
δ : Type ?u.347218
ι : Type ?u.347221
R : Type ?u.347224
R' : Type ?u.347227
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν✝ ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
μ ν : ℕ → Measure α
s : Set α
hs : MeasurableSet s
⊢ ↑↑(sum μ + sum ν) s = ↑↑(sum fun n => μ n + ν n) s
Theorem: Int.le_induction
File: Mathlib/Data/Int/Order/Basic.lean

tactic: refine Int.inductionOn' n m ?_ ?_ ?_
state_before: P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ m ≤ n → P n

tactic: intro
state_before: case refine_1
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ m ≤ m → P m

tactic: exact h0
state_before: case refine_1
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
a✝ : m ≤ m
⊢ P m

tactic: intro k hle hi _
state_before: case refine_2
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ ∀ (k : ℤ), m ≤ k → (m ≤ k → P k) → m ≤ k + 1 → P (k + 1)

tactic: exact h1 k hle (hi hle)
state_before: case refine_2
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n k : ℤ
hle : m ≤ k
hi : m ≤ k → P k
a✝ : m ≤ k + 1
⊢ P (k + 1)

tactic: intro k hle _ hle'
state_before: case refine_3
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ ∀ (k : ℤ), k ≤ m → (m ≤ k → P k) → m ≤ k - 1 → P (k - 1)

tactic: exfalso
state_before: case refine_3
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n k : ℤ
hle : k ≤ m
a✝ : m ≤ k → P k
hle' : m ≤ k - 1
⊢ P (k - 1)

tactic: exact lt_irrefl k (le_sub_one_iff.mp (hle.trans hle'))
state_before: case refine_3.h
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n k : ℤ
hle : k ≤ m
a✝ : m ≤ k → P k
hle' : m ≤ k - 1
⊢ False
Theorem: Pell.x_sub_y_dvd_pow_lem
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: ring
state_before: a : ℕ
a1 : 1 < a
y2 y1 y0 yn1 yn0 xn1 xn0 ay a2 : ℤ
⊢ (a2 * yn1 - yn0) * ay + y2 - (a2 * xn1 - xn0) = y2 - a2 * y1 + y0 + a2 * (yn1 * ay + y1 - xn1) - (yn0 * ay + y0 - xn0)
Theorem: List.TProd.elim_mk
File: Mathlib/Data/Prod/TProd.lean

tactic: by_cases hji : j = i
state_before: ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f✝ : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
f : (i : ι) → α i
j : ι
hj : j ∈ i :: is
⊢ TProd.elim (TProd.mk (i :: is) f) hj = f j

tactic: subst hji
state_before: case pos
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f✝ : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
f : (i : ι) → α i
j : ι
hj : j ∈ i :: is
hji : j = i
⊢ TProd.elim (TProd.mk (i :: is) f) hj = f j

tactic: simp
state_before: case pos
ι : Type u
α : ι → Type v
i j✝ : ι
l : List ι
f✝ : (i : ι) → α i
inst✝ : DecidableEq ι
is : List ι
f : (i : ι) → α i
j : ι
hj : j ∈ j :: is
⊢ TProd.elim (TProd.mk (j :: is) f) hj = f j

tactic: rw [TProd.elim_of_ne _ hji, snd_mk, elim_mk is]
state_before: case neg
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f✝ : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
f : (i : ι) → α i
j : ι
hj : j ∈ i :: is
hji : ¬j = i
⊢ TProd.elim (TProd.mk (i :: is) f) hj = f j
Theorem: differentiableWithinAt_const_sub_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp [sub_eq_add_neg]
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.545914
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.546009
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
c : F
⊢ DifferentiableWithinAt 𝕜 (fun y => c - f y) s x ↔ DifferentiableWithinAt 𝕜 f s x
Theorem: MeasureTheory.hasFiniteIntegral_zero_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [HasFiniteIntegral, lintegral_zero_measure, WithTop.zero_lt_top]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.721423
δ : Type ?u.721426
m✝ : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
m : MeasurableSpace α
f : α → β
⊢ HasFiniteIntegral f
Theorem: Finset.map_swap_product
File: Mathlib/Data/Finset/Prod.lean

tactic: push_cast
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17685
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
s : Finset α
t : Finset β
⊢ ↑(map { toFun := Prod.swap, inj' := (_ : Function.Injective Prod.swap) } (t ×ˢ s)) = ↑(s ×ˢ t)

tactic: exact Set.image_swap_prod _ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17685
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
s : Finset α
t : Finset β
⊢ (fun a => ↑{ toFun := Prod.swap, inj' := (_ : Function.Injective Prod.swap) } a) '' ↑t ×ˢ ↑s = ↑s ×ˢ ↑t
Theorem: LazyList.mem_cons
File: Mathlib/Data/LazyList/Basic.lean

tactic: simp [Membership.mem, LazyList.Mem]
state_before: α : Type u_1
x y : α
ys : Thunk (LazyList α)
⊢ x ∈ cons y ys ↔ x = y ∨ x ∈ Thunk.get ys
Theorem: Subgroup.smul_apply_eq_smul_apply_inv_smul
File: Mathlib/GroupTheory/Complement.lean

tactic: rw [smul_toEquiv, smul_inv_smul]
state_before: G : Type u_1
inst✝³ : Group G
H K : Subgroup G
S T✝ : Set G
F : Type u_2
inst✝² : Group F
inst✝¹ : MulAction F G
inst✝ : QuotientAction F H
f : F
T : ↑(leftTransversals ↑H)
q : G ⧸ H
⊢ ↑(↑(toEquiv (_ : ↑(f • T) ∈ leftTransversals ↑H)) q) = f • ↑(↑(toEquiv (_ : ↑T ∈ leftTransversals ↑H)) (f⁻¹ • q))
Theorem: Ideal.prod_eq_bot
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [bot_eq_zero, prod_zero_iff_exists_zero]
state_before: R✝ : Type u
ι : Type ?u.301378
inst✝² : CommSemiring R✝
I J K L : Ideal R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
s : Multiset (Ideal R)
⊢ Multiset.prod s = ⊥ ↔ ∃ I, I ∈ s ∧ I = ⊥

tactic: simp
state_before: R✝ : Type u
ι : Type ?u.301378
inst✝² : CommSemiring R✝
I J K L : Ideal R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
s : Multiset (Ideal R)
⊢ (∃ r x, r = 0) ↔ ∃ I, I ∈ s ∧ I = 0
Theorem: IntermediateField.coe_iInf
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp [iInf]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
ι : Sort u_1
S : ι → IntermediateField F E
⊢ ↑(iInf S) = ⋂ (i : ι), ↑(S i)
Theorem: Stream'.WSeq.drop.aux_none
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [ret_bind, drop.aux_none n]
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
⊢ Computation.bind (Computation.pure none) (aux n) = Computation.pure none
Theorem: Fin.castSucc_pred_eq_pred_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: cases a
state_before: n m : ℕ
a : Fin (n + 1)
ha : a ≠ 0
ha' : optParam (↑castSucc a ≠ 0) (_ : ↑castSucc a ≠ 0)
⊢ ↑castSucc (pred a ha) = pred (↑castSucc a) ha'

tactic: rfl
state_before: case mk
n m val✝ : ℕ
isLt✝ : val✝ < n + 1
ha : { val := val✝, isLt := isLt✝ } ≠ 0
ha' : optParam (↑castSucc { val := val✝, isLt := isLt✝ } ≠ 0) (_ : ↑castSucc { val := val✝, isLt := isLt✝ } ≠ 0)
⊢ ↑castSucc (pred { val := val✝, isLt := isLt✝ } ha) = pred (↑castSucc { val := val✝, isLt := isLt✝ }) ha'
Theorem: Prod.mk_wcovby_mk_iff
File: Mathlib/Order/Cover.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂

tactic: obtain rfl | rfl : a₁ = a₂ ∨ b₁ = b₂ := fst_eq_or_snd_eq_of_wcovby h
state_before: case refine'_1
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : (a₁, b₁) ⩿ (a₂, b₂)
⊢ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂

tactic: exact Or.inr ⟨mk_wcovby_mk_iff_right.1 h, rfl⟩
state_before: case refine'_1.inl
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ : α
b b₁ b₂ : β
x y : α × β
h : (a₁, b₁) ⩿ (a₁, b₂)
⊢ a₁ ⩿ a₁ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₁

tactic: exact Or.inl ⟨mk_wcovby_mk_iff_left.1 h, rfl⟩
state_before: case refine'_1.inr
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ : β
x y : α × β
h : (a₁, b₁) ⩿ (a₂, b₁)
⊢ a₁ ⩿ a₂ ∧ b₁ = b₁ ∨ b₁ ⩿ b₁ ∧ a₁ = a₂

tactic: rintro (⟨h, rfl⟩ | ⟨h, rfl⟩)
state_before: case refine'_2
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂ → (a₁, b₁) ⩿ (a₂, b₂)

tactic: exact mk_wcovby_mk_iff_left.2 h
state_before: case refine'_2.inl.intro
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ : β
x y : α × β
h : a₁ ⩿ a₂
⊢ (a₁, b₁) ⩿ (a₂, b₁)

tactic: exact mk_wcovby_mk_iff_right.2 h
state_before: case refine'_2.inr.intro
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ : α
b b₁ b₂ : β
x y : α × β
h : b₁ ⩿ b₂
⊢ (a₁, b₁) ⩿ (a₁, b₂)
Theorem: eq_true_eq_id
File: Mathlib/Logic/Basic.lean

tactic: funext _
state_before: ⊢ Eq True = id

tactic: simp only [true_iff, id.def, eq_iff_iff]
state_before: case h
x✝ : Prop
⊢ (True = x✝) = id x✝
Theorem: zpowersEquivZpowers_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [zpowersEquivZpowers, Equiv.trans_apply, Equiv.trans_apply, finEquivZpowers_symm_apply, ←
  Equiv.eq_symm_apply, finEquivZpowers_symm_apply]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Finite G
h : orderOf x = orderOf y
n : ℕ
⊢ ↑(zpowersEquivZpowers h) { val := x ^ n, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) x y = x ^ n) } =
    { val := y ^ n, property := (_ : ∃ y_1, (fun x x_1 => x ^ x_1) y y_1 = y ^ n) }

tactic: simp [h]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Finite G
h : orderOf x = orderOf y
n : ℕ
⊢ ↑(Fin.cast h).toEquiv { val := n % orderOf x, isLt := (_ : n % orderOf x < orderOf x) } =
    { val := n % orderOf y, isLt := (_ : n % orderOf y < orderOf y) }
Theorem: MeasureTheory.ae_restrict_iff'₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' ⟨fun h => ae_imp_of_ae_restrict h, fun h => _⟩
state_before: α : Type u_1
β : Type ?u.576111
γ : Type ?u.576114
δ : Type ?u.576117
ι : Type ?u.576120
R : Type ?u.576123
R' : Type ?u.576126
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
p : α → Prop
hs : NullMeasurableSet s
⊢ (∀ᵐ (x : α) ∂Measure.restrict μ s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x

tactic: filter_upwards [ae_restrict_mem₀ hs, ae_restrict_of_ae h]with x hx h'x using h'x hx
state_before: α : Type u_1
β : Type ?u.576111
γ : Type ?u.576114
δ : Type ?u.576117
ι : Type ?u.576120
R : Type ?u.576123
R' : Type ?u.576126
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
p : α → Prop
hs : NullMeasurableSet s
h : ∀ᵐ (x : α) ∂μ, x ∈ s → p x
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ s, p x
Theorem: Asymptotics.IsEquivalent.add_isLittleO
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: simpa only [IsEquivalent, add_sub_right_comm] using huv.add hwv
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hwv : w =o[l] v
⊢ u + w ~[l] v
Theorem: rel_sup_add
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: convert rel_iSup_tsum m m0 R m_iSup fun b => cond b s₁ s₂
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.378311
δ : Type ?u.378314
inst✝⁴ : AddCommMonoid α
inst✝³ : TopologicalSpace α
inst✝² : T2Space α
f g : β → α
a a₁ a₂ : α
inst✝¹ : Countable γ
inst✝ : CompleteLattice β
m : β → α
m0 : m ⊥ = 0
R : α → α → Prop
m_iSup : ∀ (s : ℕ → β), R (m (⨆ (i : ℕ), s i)) (∑' (i : ℕ), m (s i))
s₁ s₂ : β
⊢ R (m (s₁ ⊔ s₂)) (m s₁ + m s₂)

tactic: simp only [iSup_bool_eq, cond]
state_before: case h.e'_1.h.e'_1
α : Type u_2
β : Type u_1
γ : Type ?u.378311
δ : Type ?u.378314
inst✝⁴ : AddCommMonoid α
inst✝³ : TopologicalSpace α
inst✝² : T2Space α
f g : β → α
a a₁ a₂ : α
inst✝¹ : Countable γ
inst✝ : CompleteLattice β
m : β → α
m0 : m ⊥ = 0
R : α → α → Prop
m_iSup : ∀ (s : ℕ → β), R (m (⨆ (i : ℕ), s i)) (∑' (i : ℕ), m (s i))
s₁ s₂ : β
⊢ s₁ ⊔ s₂ = ⨆ (b : Bool), bif b then s₁ else s₂

tactic: rw [tsum_fintype, Fintype.sum_bool, cond, cond]
state_before: case h.e'_2
α : Type u_2
β : Type u_1
γ : Type ?u.378311
δ : Type ?u.378314
inst✝⁴ : AddCommMonoid α
inst✝³ : TopologicalSpace α
inst✝² : T2Space α
f g : β → α
a a₁ a₂ : α
inst✝¹ : Countable γ
inst✝ : CompleteLattice β
m : β → α
m0 : m ⊥ = 0
R : α → α → Prop
m_iSup : ∀ (s : ℕ → β), R (m (⨆ (i : ℕ), s i)) (∑' (i : ℕ), m (s i))
s₁ s₂ : β
⊢ m s₁ + m s₂ = ∑' (b : Bool), m (bif b then s₁ else s₂)
Theorem: Nat.pos_of_bit0_pos
File: Mathlib/Data/Nat/Bits.lean

tactic: cases n
state_before: n✝ n : ℕ
h : 0 < bit0 n
⊢ 0 < n

tactic: cases h
state_before: case zero
n : ℕ
h : 0 < bit0 zero
⊢ 0 < zero

tactic: apply succ_pos
state_before: case succ
n n✝ : ℕ
h : 0 < bit0 (succ n✝)
⊢ 0 < succ n✝
Theorem: CategoryTheory.kernel_zero_of_nonzero_from_simple
File: Mathlib/CategoryTheory/Simple.lean

tactic: classical
  by_contra h
  haveI := isIso_of_mono_of_nonzero h
  exact w (eq_zero_of_epi_kernel f)
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
⊢ kernel.ι f = 0

tactic: by_contra h
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
⊢ kernel.ι f = 0

tactic: haveI := isIso_of_mono_of_nonzero h
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
h : ¬kernel.ι f = 0
⊢ False

tactic: exact w (eq_zero_of_epi_kernel f)
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
h : ¬kernel.ι f = 0
this : IsIso (kernel.ι f)
⊢ False
Theorem: CategoryTheory.Limits.imageSubobject_mono
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X Y Z : C
f✝ : X ⟶ Y
inst✝¹ : HasImage f✝
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageSubobjectIso f ≪≫ imageMonoIsoSource f ≪≫ (underlyingIso f).symm).hom ≫ arrow (Subobject.mk f) =
    arrow (imageSubobject f)
Theorem: Complex.arg_le_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: cases' le_or_lt 0 (re z) with hre hre
state_before: z : ℂ
⊢ arg z ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

tactic: simp only [hre.not_le, false_or_iff]
state_before: case inr
z : ℂ
hre : z.re < 0
⊢ arg z ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

tactic: cases' le_or_lt 0 (im z) with him him
state_before: case inr
z : ℂ
hre : z.re < 0
⊢ arg z ≤ π / 2 ↔ z.im < 0

tactic: simp only [hre, arg_of_re_nonneg hre, Real.arcsin_le_pi_div_two, true_or_iff]
state_before: case inl
z : ℂ
hre : 0 ≤ z.re
⊢ arg z ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

tactic: simp only [him.not_lt]
state_before: case inr.inl
z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ arg z ≤ π / 2 ↔ z.im < 0

tactic: rw [iff_false_iff, not_le, arg_of_re_neg_of_im_nonneg hre him, ← sub_lt_iff_lt_add, half_sub,
  Real.neg_pi_div_two_lt_arcsin, neg_im, neg_div, neg_lt_neg_iff, div_lt_one, ←
  _root_.abs_of_nonneg him, abs_im_lt_abs]
state_before: case inr.inl
z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ arg z ≤ π / 2 ↔ False

tactic: exacts [hre.ne, abs.pos <| ne_of_apply_ne re hre.ne]
state_before: case inr.inl
z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.re ≠ 0

case inr.inl
z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ 0 < ↑abs z

tactic: simp only [him]
state_before: case inr.inr
z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ arg z ≤ π / 2 ↔ z.im < 0

tactic: rw [iff_true_iff, arg_of_re_neg_of_im_neg hre him]
state_before: case inr.inr
z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ arg z ≤ π / 2 ↔ True

tactic: exact (sub_le_self _ Real.pi_pos.le).trans (Real.arcsin_le_pi_div_two _)
state_before: case inr.inr
z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ arcsin ((-z).im / ↑abs z) - π ≤ π / 2
Theorem: Polynomial.prod_cyclotomic'_eq_X_pow_sub_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: have hd : (n.divisors : Set ℕ).PairwiseDisjoint fun k => primitiveRoots k K :=
  fun x _ y _ hne => IsPrimitiveRoot.disjoint hne
state_before: K✝ : Type ?u.240784
inst✝² : Field K✝
K : Type u_1
inst✝¹ : CommRing K
inst✝ : IsDomain K
ζ : K
n : ℕ
hpos : 0 < n
h : IsPrimitiveRoot ζ n
⊢ ∏ i in Nat.divisors n, cyclotomic' i K = X ^ n - 1

tactic: simp only [X_pow_sub_one_eq_prod hpos h, cyclotomic', ← Finset.prod_biUnion hd,
  h.nthRoots_one_eq_biUnion_primitiveRoots]
state_before: K✝ : Type ?u.240784
inst✝² : Field K✝
K : Type u_1
inst✝¹ : CommRing K
inst✝ : IsDomain K
ζ : K
n : ℕ
hpos : 0 < n
h : IsPrimitiveRoot ζ n
hd : Set.PairwiseDisjoint ↑(Nat.divisors n) fun k => primitiveRoots k K
⊢ ∏ i in Nat.divisors n, cyclotomic' i K = X ^ n - 1
Theorem: contDiffOn_of_subsingleton
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [Subsingleton.elim f fun _ => 0]
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.64561
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
inst✝ : Subsingleton F
⊢ ContDiffOn 𝕜 n f s

tactic: exact contDiffOn_const
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.64561
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
inst✝ : Subsingleton F
⊢ ContDiffOn 𝕜 n (fun x => 0) s
Theorem: HasFDerivWithinAt.uniqueDiffWithinAt
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: refine' ⟨h'.dense_of_mapsTo f'.continuous hs.1 _, h.continuousWithinAt.mem_closure_image hs.2⟩
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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
hs : UniqueDiffWithinAt 𝕜 s x
h' : DenseRange ↑f'
⊢ UniqueDiffWithinAt 𝕜 (f '' s) (f x)

tactic: show
  Submodule.span 𝕜 (tangentConeAt 𝕜 s x) ≤
    (Submodule.span 𝕜 (tangentConeAt 𝕜 (f '' s) (f x))).comap f'
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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
hs : UniqueDiffWithinAt 𝕜 s x
h' : DenseRange ↑f'
⊢ MapsTo ↑f' ↑(Submodule.span 𝕜 (tangentConeAt 𝕜 s x)) ↑(Submodule.span 𝕜 (tangentConeAt 𝕜 (f '' s) (f x)))

tactic: rw [Submodule.span_le]
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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
hs : UniqueDiffWithinAt 𝕜 s x
h' : DenseRange ↑f'
⊢ Submodule.span 𝕜 (tangentConeAt 𝕜 s x) ≤ Submodule.comap f' (Submodule.span 𝕜 (tangentConeAt 𝕜 (f '' s) (f x)))

tactic: exact h.mapsTo_tangent_cone.mono Subset.rfl Submodule.subset_span
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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
hs : UniqueDiffWithinAt 𝕜 s x
h' : DenseRange ↑f'
⊢ tangentConeAt 𝕜 s x ⊆ ↑(Submodule.comap f' (Submodule.span 𝕜 (tangentConeAt 𝕜 (f '' s) (f x))))
Theorem: padicValNat_dvd_iff_le
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [pow_dvd_iff_le_multiplicity, ← padicValNat_def' hp.out.ne_one ha.bot_lt, PartENat.coe_le_coe]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a n : ℕ
ha : a ≠ 0
⊢ p ^ n ∣ a ↔ n ≤ padicValNat p a
Theorem: Nat.sub_le
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction m with
| zero      => exact Nat.le_refl (n - 0)
| succ m ih => apply Nat.le_trans (pred_le (n - m)) ih
state_before: n m : Nat
⊢ n - m ≤ n

tactic: exact Nat.le_refl (n - 0)
state_before: case zero
n : Nat
⊢ n - zero ≤ n

tactic: apply Nat.le_trans (pred_le (n - m)) ih
state_before: case succ
n m : Nat
ih : n - m ≤ n
⊢ n - succ m ≤ n
Theorem: ProbabilityTheory.kernel.sum_apply'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [sum_apply κ a, Measure.sum_apply _ hs]
state_before: α : Type u_2
β : Type u_3
ι : Type u_1
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
inst✝ : Countable ι
κ : ι → { x // x ∈ kernel α β }
a : α
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑(kernel.sum κ) a) s = ∑' (n : ι), ↑↑(↑(κ n) a) s
Theorem: Stream'.map_eq
File: Mathlib/Data/Stream/Init.lean

tactic: rw [← Stream'.eta (map f s), tail_map, head_map]
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
s : Stream' α
⊢ map f s = f (head s) :: map f (tail s)
Theorem: smul_lt_smul_of_neg
File: Mathlib/Algebra/Order/Module.lean

tactic: rw [← neg_neg c, neg_smul, neg_smul (-c), neg_lt_neg_iff]
state_before: k : Type u_2
M : Type u_1
N : Type ?u.7657
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
h : a < b
hc : c < 0
⊢ c • b < c • a

tactic: exact smul_lt_smul_of_pos h (neg_pos_of_neg hc)
state_before: k : Type u_2
M : Type u_1
N : Type ?u.7657
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
h : a < b
hc : c < 0
⊢ -c • a < -c • b
Theorem: RingHom.range_eq_map
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: ext
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
g : S →+* T
f✝ f : R →+* S
⊢ range f = Subring.map f ⊤

tactic: simp
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
g : S →+* T
f✝ f : R →+* S
x✝ : S
⊢ x✝ ∈ range f ↔ x✝ ∈ Subring.map f ⊤
Theorem: Polynomial.degree_X_pow_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [C_1, one_mul] using degree_C_mul_X_pow_le n (1 : R)
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ degree (X ^ n) ≤ ↑n
Theorem: lt_inv_iff_mul_lt_one'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_inv_self]
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 < b * b⁻¹ ↔ b * a < 1