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

tactic: rcases sign_cases_of_C_mul_pow_nonneg fun n => dist_nonneg.trans (hu n) with (rfl | ⟨_, r₀⟩)
state_before: α : Type ?u.447120
β : Type ?u.447123
ι : Type ?u.447126
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ HasSum (fun n => C * r ^ n) (C / (1 - r))

tactic: simp [hasSum_zero]
state_before: case inl
α : Type ?u.447120
β : Type ?u.447123
ι : Type ?u.447126
inst✝ : PseudoMetricSpace α
r : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ 0 * r ^ n
⊢ HasSum (fun n => 0 * r ^ n) (0 / (1 - r))

tactic: refine' HasSum.mul_left C _
state_before: case inr.intro
α : Type ?u.447120
β : Type ?u.447123
ι : Type ?u.447126
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
left✝ : 0 < C
r₀ : 0 ≤ r
⊢ HasSum (fun n => C * r ^ n) (C / (1 - r))

tactic: simpa using hasSum_geometric_of_lt_1 r₀ hr
state_before: case inr.intro
α : Type ?u.447120
β : Type ?u.447123
ι : Type ?u.447126
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
left✝ : 0 < C
r₀ : 0 ≤ r
⊢ HasSum (fun n => r ^ n) (1 - r)⁻¹
Theorem: Set.disjoint_image_image
File: Mathlib/Data/Set/Image.lean

tactic: rintro a ⟨⟨b, hb, eq⟩, c, hc, rfl⟩
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
f✝ : α → β
s✝ t✝ : Set α
f : β → α
g : γ → α
s : Set β
t : Set γ
h : ∀ (b : β), b ∈ s → ∀ (c : γ), c ∈ t → f b ≠ g c
⊢ f '' s ⊓ g '' t ≤ ⊥

tactic: exact h b hb c hc eq
state_before: case intro.intro.intro.intro.intro
α : Type u_3
β : Type u_1
γ : Type u_2
f✝ : α → β
s✝ t✝ : Set α
f : β → α
g : γ → α
s : Set β
t : Set γ
h : ∀ (b : β), b ∈ s → ∀ (c : γ), c ∈ t → f b ≠ g c
b : β
hb : b ∈ s
c : γ
hc : c ∈ t
eq : f b = g c
⊢ g c ∈ ⊥
Theorem: Real.rpow_def_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def_of_nonneg (le_of_lt hx), if_neg (ne_of_gt hx)]
state_before: x : ℝ
hx : 0 < x
y : ℝ
⊢ x ^ y = exp (log x * y)
Theorem: Basis.linearIndependent
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [hl, LinearEquiv.map_zero]
state_before: ι : Type u_1
ι' : Type ?u.456903
R : Type u_2
R₂ : Type ?u.456909
K : Type ?u.456912
M : Type u_3
M' : Type ?u.456918
M'' : Type ?u.456921
V : Type u
V' : Type ?u.456926
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
l : ι →₀ R
hl : ↑(Finsupp.total ι M R ↑b) l = 0
⊢ ↑b.repr (↑(Finsupp.total ι M R ↑b) l) = 0
Theorem: Std.RBNode.IsCut.congr
File: Std/Data/RBMap/Lemmas.lean

tactic: cases ey : cut y
state_before: α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
⊢ cut x = cut y

tactic: exact IsCut.le_lt_trans (fun h => nomatch H.symm.trans <| OrientedCmp.cmp_eq_gt.1 h) ey
state_before: case lt
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.lt
⊢ cut x = Ordering.lt

tactic: cases ex : cut x
state_before: case eq
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.eq
⊢ cut x = Ordering.eq

tactic: exact IsCut.le_lt_trans (fun h => nomatch H.symm.trans h) ex |>.symm.trans ey
state_before: case eq.lt
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.eq
ex : cut x = Ordering.lt
⊢ Ordering.lt = Ordering.eq

tactic: rfl
state_before: case eq.eq
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.eq
ex : cut x = Ordering.eq
⊢ Ordering.eq = Ordering.eq

tactic: refine IsCut.le_gt_trans (cmp := cmp) (fun h => ?_) ex |>.symm.trans ey
state_before: case eq.gt
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.eq
ex : cut x = Ordering.gt
⊢ Ordering.gt = Ordering.eq

tactic: cases H.symm.trans <| OrientedCmp.cmp_eq_gt.1 h
state_before: case eq.gt
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.eq
ex : cut x = Ordering.gt
h : cmp y x = Ordering.gt
⊢ False

tactic: exact IsCut.le_gt_trans (fun h => nomatch H.symm.trans h) ey
state_before: case gt
α✝ : Sort u_1
cmp : α✝ → α✝ → Ordering
cut : α✝ → Ordering
x y : α✝
inst✝¹ : IsCut cmp cut
inst✝ : TransCmp cmp
H : cmp x y = Ordering.eq
ey : cut y = Ordering.gt
⊢ cut x = Ordering.gt
Theorem: symmDiff_le_iff
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [symmDiff, sup_le_iff, sdiff_le_iff]
state_before: ι : Type ?u.21355
α : Type u_1
β : Type ?u.21361
π : ι → Type ?u.21366
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ a ∆ b ≤ c ↔ a ≤ b ⊔ c ∧ b ≤ a ⊔ c
Theorem: integrableOn_Icc_iff_integrableOn_Ico'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: by_cases hab : a ≤ b
state_before: α : Type u_1
β : Type ?u.3185262
E : Type u_2
F : Type ?u.3185268
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
⊢ IntegrableOn f (Icc a b) ↔ IntegrableOn f (Ico a b)

tactic: rw [← Ico_union_right hab, integrableOn_union,
  eq_true (integrableOn_singleton_iff.mpr <| Or.inr hb.lt_top), and_true_iff]
state_before: case pos
α : Type u_1
β : Type ?u.3185262
E : Type u_2
F : Type ?u.3185268
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
hab : a ≤ b
⊢ IntegrableOn f (Icc a b) ↔ IntegrableOn f (Ico a b)

tactic: rw [Icc_eq_empty hab, Ico_eq_empty]
state_before: case neg
α : Type u_1
β : Type ?u.3185262
E : Type u_2
F : Type ?u.3185268
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
hab : ¬a ≤ b
⊢ IntegrableOn f (Icc a b) ↔ IntegrableOn f (Ico a b)

tactic: contrapose! hab
state_before: case neg
α : Type u_1
β : Type ?u.3185262
E : Type u_2
F : Type ?u.3185268
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
hab : ¬a ≤ b
⊢ ¬a < b

tactic: exact hab.le
state_before: case neg
α : Type u_1
β : Type ?u.3185262
E : Type u_2
F : Type ?u.3185268
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
hab : a < b
⊢ a ≤ b
Theorem: Finset.right_eq_union_iff_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← union_eq_right_iff_subset, eq_comm]
state_before: α : Type u_1
β : Type ?u.151794
γ : Type ?u.151797
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
s t : Finset α
⊢ s = t ∪ s ↔ t ⊆ s
Theorem: min_eq_iff
File: Mathlib/Order/MinMax.lean

tactic: constructor
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
⊢ min a b = c ↔ a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a

tactic: intro h
state_before: case mp
α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
⊢ min a b = c → a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a

tactic: refine' Or.imp (fun h' => _) (fun h' => _) (le_total a b) <;> exact ⟨by simpa [h'] using h, h'⟩
state_before: case mp
α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
h : min a b = c
⊢ a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a

tactic: simpa [h'] using h
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
h : min a b = c
h' : b ≤ a
⊢ b = c

tactic: rintro (⟨rfl, h⟩ | ⟨rfl, h⟩) <;> simp [h]
state_before: case mpr
α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
⊢ a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a → min a b = c
Theorem: Fin.contractNth_apply_of_ne
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rcases lt_trichotomy (k : ℕ) j with (h | h | h)
state_before: m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
hjk : ↑j ≠ ↑k
⊢ contractNth j op g k = g (↑(succAbove j) k)

tactic: rwa [j.succAbove_below, contractNth_apply_of_lt]
state_before: case inl
m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
hjk : ↑j ≠ ↑k
h : ↑k < ↑j
⊢ contractNth j op g k = g (↑(succAbove j) k)

tactic: rwa [Fin.lt_iff_val_lt_val]
state_before: case inl.h
m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
hjk : ↑j ≠ ↑k
h : ↑k < ↑j
⊢ ↑castSucc k < j

tactic: exact False.elim (hjk h.symm)
state_before: case inr.inl
m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
hjk : ↑j ≠ ↑k
h : ↑k = ↑j
⊢ contractNth j op g k = g (↑(succAbove j) k)

tactic: rwa [j.succAbove_above, contractNth_apply_of_gt]
state_before: case inr.inr
m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
hjk : ↑j ≠ ↑k
h : ↑j < ↑k
⊢ contractNth j op g k = g (↑(succAbove j) k)

tactic: exact Fin.le_iff_val_le_val.2 (le_of_lt h)
state_before: case inr.inr.h
m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
hjk : ↑j ≠ ↑k
h : ↑j < ↑k
⊢ j ≤ ↑castSucc k
Theorem: Finset.weightedVSub_apply_const
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSub, weightedVSubOfPoint_apply_const, h, zero_smul]
state_before: k : Type u_1
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.153989
s₂ : Finset ι₂
w : ι → k
p : P
h : ∑ i in s, w i = 0
⊢ ↑(weightedVSub s fun x => p) w = 0
Theorem: MultilinearMap.map_smul_univ
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: classical simpa using map_piecewise_smul f c m Finset.univ
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
c : ι → R
m : (i : ι) → M₁ i
⊢ (↑f fun i => c i • m i) = (∏ i : ι, c i) • ↑f m

tactic: simpa using map_piecewise_smul f c m Finset.univ
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
c : ι → R
m : (i : ι) → M₁ i
⊢ (↑f fun i => c i • m i) = (∏ i : ι, c i) • ↑f m
Theorem: tendstoUniformly_iff_tendstoUniformlyOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, principal_univ]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ TendstoUniformly F f p ↔ TendstoUniformlyOnFilter F f p ⊤
Theorem: Set.ordConnectedComponent_univ
File: Mathlib/Data/Set/Intervals/OrdConnectedComponent.lean

tactic: simp [ordConnectedComponent]
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x y z : α
⊢ ordConnectedComponent univ x = univ
Theorem: Set.toFinset_ssubset
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← Finset.coe_ssubset, coe_toFinset]
state_before: α : Type u_1
β : Type ?u.84031
γ : Type ?u.84034
s t✝ : Set α
inst✝ : Fintype ↑s
t : Finset α
⊢ toFinset s ⊂ t ↔ s ⊂ ↑t
Theorem: Filter.prod_principal_principal
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [SProd.sprod, Filter.prod, comap_principal, principal_eq_iff_eq, comap_principal,
  inf_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.43185
δ : Type ?u.43188
ι : Sort ?u.43191
s✝ : Set α
t✝ : Set β
f : Filter α
g : Filter β
s : Set α
t : Set β
⊢ 𝓟 s ×ˢ 𝓟 t = 𝓟 (s ×ˢ t)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.43185
δ : Type ?u.43188
ι : Sort ?u.43191
s✝ : Set α
t✝ : Set β
f : Filter α
g : Filter β
s : Set α
t : Set β
⊢ Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t = prod s t
Theorem: Set.pi_if
File: Mathlib/Data/Set/Prod.lean

tactic: ext f
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.138170
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
⊢ (pi s fun i => if p i then t₁ i else t₂ i) = pi {i | i ∈ s ∧ p i} t₁ ∩ pi {i | i ∈ s ∧ ¬p i} t₂

tactic: refine' ⟨fun h => _, _⟩
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.138170
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
⊢ (f ∈ pi s fun i => if p i then t₁ i else t₂ i) ↔ f ∈ pi {i | i ∈ s ∧ p i} t₁ ∩ pi {i | i ∈ s ∧ ¬p i} t₂

tactic: rintro i ⟨his, hpi⟩
state_before: case h.refine'_1.right
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.138170
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h✝ : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
h : f ∈ pi s fun i => if p i then t₁ i else t₂ i
⊢ f ∈ pi {i | i ∈ s ∧ ¬p i} t₂

tactic: simpa [*] using h i
state_before: case h.refine'_1.right.intro
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.138170
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i✝ : ι
p : ι → Prop
h✝ : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
h : f ∈ pi s fun i => if p i then t₁ i else t₂ i
i : ι
his : i ∈ s
hpi : ¬p i
⊢ f i ∈ t₂ i

tactic: rintro ⟨ht₁, ht₂⟩ i his
state_before: case h.refine'_2
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.138170
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
⊢ f ∈ pi {i | i ∈ s ∧ p i} t₁ ∩ pi {i | i ∈ s ∧ ¬p i} t₂ → f ∈ pi s fun i => if p i then t₁ i else t₂ i

tactic: by_cases p i <;> simp_all
state_before: case h.refine'_2.intro
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.138170
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i✝ : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
ht₁ : f ∈ pi {i | i ∈ s ∧ p i} t₁
ht₂ : f ∈ pi {i | i ∈ s ∧ ¬p i} t₂
i : ι
his : i ∈ s
⊢ f i ∈ (fun i => if p i then t₁ i else t₂ i) i
Theorem: Finset.untrop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: simpa [← _root_.untrop_sum] using sum_attach.symm
state_before: R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → Tropical (WithTop R)
⊢ untrop (∑ i in s, f i) = ⨅ (i : { x // x ∈ s }), untrop (f ↑i)
Theorem: SimpleGraph.Walk.darts_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
⊢ darts (Walk.map f p) = List.map (Hom.mapDart f) (darts p)
Theorem: Sym2.gameAdd_iff
File: Mathlib/Order/GameAdd.lean

tactic: rintro ⟨_, _⟩ ⟨_, _⟩
state_before: α : Type u_1
β : Type ?u.5319
rα : α → α → Prop
rβ : β → β → Prop
⊢ ∀ {x y : α × α},
    GameAdd rα (Quotient.mk (Rel.setoid α) x) (Quotient.mk (Rel.setoid α) y) ↔
      Prod.GameAdd rα rα x y ∨ Prod.GameAdd rα rα (Prod.swap x) y

tactic: rfl
state_before: case mk.mk
α : Type u_1
β : Type ?u.5319
rα : α → α → Prop
rβ : β → β → Prop
fst✝¹ snd✝¹ fst✝ snd✝ : α
⊢ GameAdd rα (Quotient.mk (Rel.setoid α) (fst✝¹, snd✝¹)) (Quotient.mk (Rel.setoid α) (fst✝, snd✝)) ↔
    Prod.GameAdd rα rα (fst✝¹, snd✝¹) (fst✝, snd✝) ∨ Prod.GameAdd rα rα (Prod.swap (fst✝¹, snd✝¹)) (fst✝, snd✝)
Theorem: Finset.powerset_univ
File: Mathlib/Data/Fintype/Powerset.lean

tactic: simp [-coe_eq_univ]
state_before: α : Type u_1
inst✝ : Fintype α
⊢ ↑(powerset univ) = ↑univ
Theorem: ZMod.χ₈'_int_eq_if_mod_eight
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: have help :
  ∀ m : ℤ, 0 ≤ m → m < 8 → χ₈' m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1 := by
  decide
state_before: n : ℤ
⊢ ↑χ₈' ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1

tactic: rw [← Int.emod_emod_of_dvd n (by norm_num : (2 : ℤ) ∣ 8), ← ZMod.int_cast_mod n 8]
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → ↑χ₈' ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1
⊢ ↑χ₈' ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1

tactic: exact help (n % 8) (Int.emod_nonneg n (by norm_num)) (Int.emod_lt n (by norm_num))
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → ↑χ₈' ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1
⊢ ↑χ₈' ↑(n % ↑8) = if n % 8 % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1

tactic: decide
state_before: n : ℤ
⊢ ∀ (m : ℤ), 0 ≤ m → m < 8 → ↑χ₈' ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1

tactic: norm_num
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → ↑χ₈' ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1
⊢ 2 ∣ 8

tactic: norm_num
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → ↑χ₈' ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1
⊢ 8 ≠ 0

tactic: norm_num
state_before: n : ℤ
help : ∀ (m : ℤ), 0 ≤ m → m < 8 → ↑χ₈' ↑m = if m % 2 = 0 then 0 else if m = 1 ∨ m = 3 then 1 else -1
⊢ 8 ≠ 0
Theorem: Real.Angle.toReal_nonneg_iff_sign_nonneg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rcases lt_trichotomy θ.toReal 0 with (h | h | h)
state_before: θ : Angle
⊢ 0 ≤ toReal θ ↔ 0 ≤ sign θ

tactic: refine' ⟨fun hn => False.elim (h.not_le hn), fun hn => _⟩
state_before: case inl
θ : Angle
h : toReal θ < 0
⊢ 0 ≤ toReal θ ↔ 0 ≤ sign θ

tactic: rw [toReal_neg_iff_sign_neg.1 h] at hn
state_before: case inl
θ : Angle
h : toReal θ < 0
hn : 0 ≤ sign θ
⊢ 0 ≤ toReal θ

tactic: exact False.elim (hn.not_lt (by decide))
state_before: case inl
θ : Angle
h : toReal θ < 0
hn : 0 ≤ -1
⊢ 0 ≤ toReal θ

tactic: decide
state_before: θ : Angle
h : toReal θ < 0
hn : 0 ≤ -1
⊢ -1 < 0

tactic: simp [h, sign, ← sin_toReal]
state_before: case inr.inl
θ : Angle
h : toReal θ = 0
⊢ 0 ≤ toReal θ ↔ 0 ≤ sign θ

tactic: refine' ⟨fun _ => _, fun _ => h.le⟩
state_before: case inr.inr
θ : Angle
h : 0 < toReal θ
⊢ 0 ≤ toReal θ ↔ 0 ≤ sign θ

tactic: rw [sign, ← sin_toReal, sign_nonneg_iff]
state_before: case inr.inr
θ : Angle
h : 0 < toReal θ
x✝ : 0 ≤ toReal θ
⊢ 0 ≤ sign θ

tactic: exact sin_nonneg_of_nonneg_of_le_pi h.le (toReal_le_pi θ)
state_before: case inr.inr
θ : Angle
h : 0 < toReal θ
x✝ : 0 ≤ toReal θ
⊢ 0 ≤ Real.sin (toReal θ)
Theorem: SimpleGraph.Coloring.card_colorClasses_le
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: simp [colorClasses]
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝¹ : Fintype α
inst✝ : Fintype ↑(colorClasses C)
⊢ Fintype.card ↑(colorClasses C) ≤ Fintype.card α

tactic: haveI : Fintype (Setoid.classes (Setoid.ker C)) := by assumption
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝¹ : Fintype α
inst✝ : Fintype ↑(colorClasses C)
⊢ Fintype.card ↑(Setoid.classes (Setoid.ker ↑C)) ≤ Fintype.card α

tactic: convert Setoid.card_classes_ker_le C
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝¹ : Fintype α
inst✝ : Fintype ↑(colorClasses C)
this : Fintype ↑(Setoid.classes (Setoid.ker ↑C))
⊢ Fintype.card ↑(Setoid.classes (Setoid.ker ↑C)) ≤ Fintype.card α

tactic: assumption
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝¹ : Fintype α
inst✝ : Fintype ↑(colorClasses C)
⊢ Fintype ↑(Setoid.classes (Setoid.ker ↑C))
Theorem: Nat.prime_iff_prime_int
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [← Int.dvd_natAbs, Int.coe_nat_dvd, Int.natAbs_mul, hp.dvd_mul] at h
state_before: p : ℕ
hp : Prime p
a b : ℤ
h : ↑p ∣ a * b
⊢ ↑p ∣ a ∨ ↑p ∣ b

tactic: rwa [← Int.dvd_natAbs, Int.coe_nat_dvd, ← Int.dvd_natAbs, Int.coe_nat_dvd]
state_before: p : ℕ
hp : Prime p
a b : ℤ
h : p ∣ Int.natAbs a ∨ p ∣ Int.natAbs b
⊢ ↑p ∣ a ∨ ↑p ∣ b

tactic: simp [h, not_prime_one] at hp
state_before: p : ℕ
hp : _root_.Prime ↑p
h : p = 1
⊢ False

tactic: simpa only [Int.coe_nat_dvd, (Int.ofNat_mul _ _).symm] using hp.2.2 a b
state_before: p : ℕ
hp : _root_.Prime ↑p
a b : ℕ
⊢ p ∣ a * b → p ∣ a ∨ p ∣ b
Theorem: SemidirectProduct.lift_comp_inl
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext
state_before: N : Type u_1
G : Type u_3
H : Type u_2
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
⊢ MonoidHom.comp (lift f₁ f₂ h) inl = f₁

tactic: simp
state_before: case h
N : Type u_1
G : Type u_3
H : Type u_2
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
x✝ : N
⊢ ↑(MonoidHom.comp (lift f₁ f₂ h) inl) x✝ = ↑f₁ x✝
Theorem: Set.offDiag_singleton
File: Mathlib/Data/Set/Prod.lean

tactic: simp
state_before: α : Type u_1
s t : Set α
x : α × α
a✝ a : α
⊢ offDiag {a} = ∅