tasksource/leandojo huggingface dataset:
Theorem: Finset.product_inter_product
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.76606
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ s ×ˢ t ∩ s' ×ˢ t' = (s ∩ s') ×ˢ (t ∩ t')

tactic: simp only [and_assoc, and_left_comm, mem_inter, mem_product]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type ?u.76606
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ t ∩ s' ×ˢ t' ↔ (x, y) ∈ (s ∩ s') ×ˢ (t ∩ t')
Theorem: midpoint_eq_right_iff
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_comm, midpoint_eq_left_iff, eq_comm]
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.95650
P : Type u_1
P' : Type ?u.95656
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ midpoint R x y = y ↔ x = y
Theorem: Subring.prod_top
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_fst]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Subring R
x : R × S
⊢ x ∈ prod s ⊤ ↔ x ∈ comap (RingHom.fst R S) s
Theorem: Ordinal.bsup_eq_bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [bsup_eq_sup', bsup_eq_sup']
state_before: α : Type ?u.308792
β : Type ?u.308795
γ : Type ?u.308798
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r r' : ι → ι → Prop
inst✝¹ : IsWellOrder ι r
inst✝ : IsWellOrder ι r'
f : ι → Ordinal
⊢ bsup (type r) (bfamilyOfFamily' r f) = bsup (type r') (bfamilyOfFamily' r' f)
Theorem: Pmf.mem_support_bind_iff
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp only [support_bind, Set.mem_iUnion, Set.mem_setOf_eq, exists_prop]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.56378
p : Pmf α
f : α → Pmf β
g : β → Pmf γ
b : β
⊢ b ∈ support (bind p f) ↔ ∃ a, a ∈ support p ∧ b ∈ support (f a)
Theorem: CategoryTheory.Bicategory.unitors_equal
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: rw [← whiskerLeft_iff, ← cancel_epi (α_ _ _ _).hom, ← cancel_mono (ρ_ _).hom, triangle, ←
    rightUnitor_comp, rightUnitor_naturality]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
⊢ (λ_ (𝟙 a)).hom = (ρ_ (𝟙 a)).hom
Theorem: ENNReal.le_tsum_condensed
File: Mathlib/Analysis/PSeries.lean

tactic: rw [ENNReal.tsum_eq_iSup_nat' (Nat.tendsto_pow_atTop_atTop_of_one_lt _root_.one_lt_two)]
state_before: f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ (∑' (k : ℕ), f k) ≤ f 0 + ∑' (k : ℕ), 2 ^ k * f (2 ^ k)

tactic: refine' iSup_le fun n => (Finset.le_sum_condensed hf n).trans (add_le_add_left _ _)
state_before: f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ (⨆ (i : ℕ), ∑ a in Finset.range (2 ^ i), f a) ≤ f 0 + ∑' (k : ℕ), 2 ^ k * f (2 ^ k)

tactic: simp only [nsmul_eq_mul, Nat.cast_pow, Nat.cast_two]
state_before: f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ ∑ k in Finset.range n, 2 ^ k • f (2 ^ k) ≤ ∑' (k : ℕ), 2 ^ k * f (2 ^ k)

tactic: apply ENNReal.sum_le_tsum
state_before: f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ ∑ x in Finset.range n, 2 ^ x * f (2 ^ x) ≤ ∑' (k : ℕ), 2 ^ k * f (2 ^ k)
Theorem: iSup_prod
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [iSup_le_iff, Prod.forall]
state_before: α : Type u_3
β : Type u_1
β₂ : Type ?u.165662
γ : Type u_2
ι : Sort ?u.165668
ι' : Sort ?u.165671
κ : ι → Sort ?u.165676
κ' : ι' → Sort ?u.165681
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β × γ → α
c : α
⊢ (⨆ (x : β × γ), f x) ≤ c ↔ (⨆ (i : β) (j : γ), f (i, j)) ≤ c
Theorem: Set.uIcc_prod_eq
File: Mathlib/Data/Set/Intervals/UnorderedInterval.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Lattice α
inst✝ : Lattice β
a✝ a₁ a₂ b✝ b₁ b₂ c x : α
a b : α × β
⊢ [[a, b]] = [[a.fst, b.fst]] ×ˢ [[a.snd, b.snd]]
Theorem: imp_of_if_pos
File: Mathlib/Init/Logic.lean

tactic: have := if_pos hc ▸ h
state_before: a b c✝ d : Prop
p : ?m.27950
c t e : Prop
inst✝ : Decidable c
h : if c then t else e
hc : c
⊢ t

tactic: exact this
state_before: a b c✝ d : Prop
p : ?m.27950
c t e : Prop
inst✝ : Decidable c
h : if c then t else e
hc : c
this : t
⊢ t
Theorem: Valuation.map_sub
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [sub_eq_add_neg]
state_before: K : Type ?u.1561683
F : Type ?u.1561686
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.1561698
Γ''₀ : Type ?u.1561701
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
⊢ ↑v (x - y) = ↑v (x + -y)

tactic: rw [map_neg]
state_before: K : Type ?u.1561683
F : Type ?u.1561686
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.1561698
Γ''₀ : Type ?u.1561701
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x✝ y✝ z x y : R
⊢ max (↑v x) (↑v (-y)) = max (↑v x) (↑v y)
Theorem: PGame.neg_equiv_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg y, neg_equiv_neg_iff, neg_neg]
state_before: x y : PGame
⊢ (-x ≈ y) ↔ (x ≈ -y)
Theorem: MeasureTheory.integrable_withDensity_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: have : (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x := by simp [mul_comm]
state_before: α : Type u_1
β : Type ?u.1031427
γ : Type ?u.1031430
δ : Type ?u.1031433
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
⊢ Integrable g ↔ Integrable fun x => g x * ENNReal.toReal (f x)

tactic: rw [this]
state_before: α : Type u_1
β : Type ?u.1031427
γ : Type ?u.1031430
δ : Type ?u.1031433
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
this : (fun x => g x * ENNReal.toReal (f x)) = fun x => ENNReal.toReal (f x) • g x
⊢ Integrable g ↔ Integrable fun x => g x * ENNReal.toReal (f x)

tactic: exact integrable_withDensity_iff_integrable_smul' hf hflt
state_before: α : Type u_1
β : Type ?u.1031427
γ : Type ?u.1031430
δ : Type ?u.1031433
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
this : (fun x => g x * ENNReal.toReal (f x)) = fun x => ENNReal.toReal (f x) • g x
⊢ Integrable g ↔ Integrable fun x => ENNReal.toReal (f x) • g x

tactic: simp [mul_comm]
state_before: α : Type u_1
β : Type ?u.1031427
γ : Type ?u.1031430
δ : Type ?u.1031433
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
⊢ (fun x => g x * ENNReal.toReal (f x)) = fun x => ENNReal.toReal (f x) • g x
Theorem: Nat.WithBot.lt_zero_iff
File: Mathlib/Data/Nat/WithBot.lean

tactic: refine' Option.casesOn n _ _
state_before: n : WithBot ℕ
⊢ n < 0 ↔ n = ⊥

tactic: exact of_eq_true (eq_true_of_decide (Eq.refl true))
state_before: case refine'_1
n : WithBot ℕ
⊢ none < 0 ↔ none = ⊥

case refine'_2
n : WithBot ℕ
⊢ ∀ (val : ℕ), some val < 0 ↔ some val = ⊥

tactic: intro n
state_before: case refine'_2
n : WithBot ℕ
⊢ ∀ (val : ℕ), some val < 0 ↔ some val = ⊥

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: case refine'_2
n✝ : WithBot ℕ
n : ℕ
⊢ some n < 0 ↔ some n = ⊥

tactic: exfalso
state_before: case refine'_2.refine'_1
n✝ : WithBot ℕ
n : ℕ
h : some n < 0
⊢ some n = ⊥

case refine'_2.refine'_2
n✝ : WithBot ℕ
n : ℕ
h : some n = ⊥
⊢ some n < 0

tactic: rw [WithBot.some_eq_coe] at h
state_before: case refine'_2.refine'_1.h
n✝ : WithBot ℕ
n : ℕ
h : some n < 0
⊢ False

tactic: exact not_le_of_lt h WithBot.coe_nonneg
state_before: case refine'_2.refine'_1.h
n✝ : WithBot ℕ
n : ℕ
h : ↑n < 0
⊢ False

tactic: rw [h]
state_before: case refine'_2.refine'_2
n✝ : WithBot ℕ
n : ℕ
h : some n = ⊥
⊢ some n < 0

tactic: exact of_eq_true (eq_true_of_decide (Eq.refl true))
state_before: case refine'_2.refine'_2
n✝ : WithBot ℕ
n : ℕ
h : some n = ⊥
⊢ ⊥ < 0
Theorem: RingHom.map_ite_one_zero
File: Mathlib/Algebra/Hom/Ring.lean

tactic: split_ifs with h
state_before: F✝ : Type ?u.83334
α : Type u_2
β : Type u_3
γ : Type ?u.83343
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
⊢ ↑f (if p then 1 else 0) = if p then 1 else 0

tactic: simp only [h, ite_true]
state_before: case inl
F✝ : Type ?u.83334
α : Type u_2
β : Type u_3
γ : Type ?u.83343
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : p
⊢ ↑f (if p then 1 else 0) = 1

tactic: rw [map_one]
state_before: case inl
F✝ : Type ?u.83334
α : Type u_2
β : Type u_3
γ : Type ?u.83343
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : p
⊢ ↑f 1 = 1

tactic: simp only [h, ite_false]
state_before: case inr
F✝ : Type ?u.83334
α : Type u_2
β : Type u_3
γ : Type ?u.83343
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : ¬p
⊢ ↑f (if p then 1 else 0) = 0

tactic: rw [map_zero]
state_before: case inr
F✝ : Type ?u.83334
α : Type u_2
β : Type u_3
γ : Type ?u.83343
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : ¬p
⊢ ↑f 0 = 0
Theorem: Turing.proj_map_nth
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [ListBlank.nth_map]
state_before: ι : Type u_1
Γ : ι → Type u_2
inst✝ : (i : ι) → Inhabited (Γ i)
i : ι
L : ListBlank ((i : ι) → Γ i)
n : ℕ
⊢ ListBlank.nth (ListBlank.map (proj i) L) n = ListBlank.nth L n i

tactic: rfl
state_before: ι : Type u_1
Γ : ι → Type u_2
inst✝ : (i : ι) → Inhabited (Γ i)
i : ι
L : ListBlank ((i : ι) → Γ i)
n : ℕ
⊢ PointedMap.f (proj i) (ListBlank.nth L n) = ListBlank.nth L n i
Theorem: List.reduceOption_length_le
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl hl
state_before: ι : Type ?u.350604
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List (Option α)
⊢ length (reduceOption l) ≤ length l

tactic: simp only [reduceOption_nil, length]
state_before: case nil
ι : Type ?u.350604
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
⊢ length (reduceOption []) ≤ length []

tactic: cases hd
state_before: case cons
ι : Type ?u.350604
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
hd : Option α
tl : List (Option α)
hl : length (reduceOption tl) ≤ length tl
⊢ length (reduceOption (hd :: tl)) ≤ length (hd :: tl)

tactic: exact Nat.le_succ_of_le hl
state_before: case cons.none
ι : Type ?u.350604
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
tl : List (Option α)
hl : length (reduceOption tl) ≤ length tl
⊢ length (reduceOption (none :: tl)) ≤ length (none :: tl)

tactic: simpa only [length, add_le_add_iff_right, reduceOption_cons_of_some] using hl
state_before: case cons.some
ι : Type ?u.350604
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
tl : List (Option α)
hl : length (reduceOption tl) ≤ length tl
val✝ : α
⊢ length (reduceOption (some val✝ :: tl)) ≤ length (some val✝ :: tl)
Theorem: eq_of_derivWithin_eq
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: have A : ∀ y ∈ Ico a b, HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y := fun y hy =>
  (fdiff y (mem_Icc_of_Ico hy)).hasDerivWithinAt.nhdsWithin (Icc_mem_nhdsWithin_Ici hy)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.54298
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
⊢ ∀ (y : ℝ), y ∈ Icc a b → f y = g y

tactic: have B : ∀ y ∈ Ico a b, HasDerivWithinAt g (derivWithin g (Icc a b) y) (Ici y) y := fun y hy =>
  (gdiff y (mem_Icc_of_Ico hy)).hasDerivWithinAt.nhdsWithin (Icc_mem_nhdsWithin_Ici hy)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.54298
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
A : ∀ (y : ℝ), y ∈ Ico a b → HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y
⊢ ∀ (y : ℝ), y ∈ Icc a b → f y = g y

tactic: exact
  eq_of_has_deriv_right_eq A (fun y hy => (hderiv hy).symm ▸ B y hy) fdiff.continuousOn
    gdiff.continuousOn hi
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.54298
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
A : ∀ (y : ℝ), y ∈ Ico a b → HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y
B : ∀ (y : ℝ), y ∈ Ico a b → HasDerivWithinAt g (derivWithin g (Icc a b) y) (Ici y) y
⊢ ∀ (y : ℝ), y ∈ Icc a b → f y = g y
Theorem: Seminorm.finset_sup_apply_le
File: Mathlib/Analysis/Seminorm.lean

tactic: lift a to ℝ≥0 using ha
state_before: R : Type ?u.518585
R' : Type ?u.518588
𝕜 : Type u_1
𝕜₂ : Type ?u.518594
𝕜₃ : Type ?u.518597
𝕝 : Type ?u.518600
E : Type u_2
E₂ : Type ?u.518606
E₃ : Type ?u.518609
F : Type ?u.518612
G : Type ?u.518615
ι : Type u_3
inst✝¹⁸ : SeminormedRing 𝕜
inst✝¹⁷ : SeminormedRing 𝕜₂
inst✝¹⁶ : SeminormedRing 𝕜₃
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹⁵ : RingHomIsometric σ₁₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
inst✝¹⁴ : RingHomIsometric σ₂₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹³ : RingHomIsometric σ₁₃
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup E₂
inst✝¹⁰ : AddCommGroup E₃
inst✝⁹ : AddCommGroup F
inst✝⁸ : AddCommGroup G
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜₂ E₂
inst✝⁵ : Module 𝕜₃ E₃
inst✝⁴ : Module 𝕜 F
inst✝³ : Module 𝕜 G
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
a : ℝ
ha : 0 ≤ a
h : ∀ (i : ι), i ∈ s → ↑(p i) x ≤ a
⊢ ↑(Finset.sup s p) x ≤ a

tactic: rw [finset_sup_apply, NNReal.coe_le_coe]
state_before: case intro
R : Type ?u.518585
R' : Type ?u.518588
𝕜 : Type u_1
𝕜₂ : Type ?u.518594
𝕜₃ : Type ?u.518597
𝕝 : Type ?u.518600
E : Type u_2
E₂ : Type ?u.518606
E₃ : Type ?u.518609
F : Type ?u.518612
G : Type ?u.518615
ι : Type u_3
inst✝¹⁸ : SeminormedRing 𝕜
inst✝¹⁷ : SeminormedRing 𝕜₂
inst✝¹⁶ : SeminormedRing 𝕜₃
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹⁵ : RingHomIsometric σ₁₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
inst✝¹⁴ : RingHomIsometric σ₂₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹³ : RingHomIsometric σ₁₃
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup E₂
inst✝¹⁰ : AddCommGroup E₃
inst✝⁹ : AddCommGroup F
inst✝⁸ : AddCommGroup G
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜₂ E₂
inst✝⁵ : Module 𝕜₃ E₃
inst✝⁴ : Module 𝕜 F
inst✝³ : Module 𝕜 G
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
a : ℝ≥0
h : ∀ (i : ι), i ∈ s → ↑(p i) x ≤ ↑a
⊢ ↑(Finset.sup s p) x ≤ ↑a

tactic: exact Finset.sup_le h
state_before: case intro
R : Type ?u.518585
R' : Type ?u.518588
𝕜 : Type u_1
𝕜₂ : Type ?u.518594
𝕜₃ : Type ?u.518597
𝕝 : Type ?u.518600
E : Type u_2
E₂ : Type ?u.518606
E₃ : Type ?u.518609
F : Type ?u.518612
G : Type ?u.518615
ι : Type u_3
inst✝¹⁸ : SeminormedRing 𝕜
inst✝¹⁷ : SeminormedRing 𝕜₂
inst✝¹⁶ : SeminormedRing 𝕜₃
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹⁵ : RingHomIsometric σ₁₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
inst✝¹⁴ : RingHomIsometric σ₂₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹³ : RingHomIsometric σ₁₃
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup E₂
inst✝¹⁰ : AddCommGroup E₃
inst✝⁹ : AddCommGroup F
inst✝⁸ : AddCommGroup G
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜₂ E₂
inst✝⁵ : Module 𝕜₃ E₃
inst✝⁴ : Module 𝕜 F
inst✝³ : Module 𝕜 G
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
a : ℝ≥0
h : ∀ (i : ι), i ∈ s → ↑(p i) x ≤ ↑a
⊢ (Finset.sup s fun i => { val := ↑(p i) x, property := (_ : 0 ≤ ↑(p i) x) }) ≤ a
Theorem: Equiv.Perm.sign_subtypeCongr
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp [subtypeCongr]
state_before: α : Type u
β : Type v
inst✝⁴ : DecidableEq α
inst✝³ : Fintype α
inst✝² : DecidableEq β
inst✝¹ : Fintype β
p : α → Prop
inst✝ : DecidablePred p
ep : Perm { a // p a }
en : Perm { a // ¬p a }
⊢ ↑sign (subtypeCongr ep en) = ↑sign ep * ↑sign en
Theorem: Real.logb_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp [logb]
state_before: b x y : ℝ
⊢ logb b 1 = 0
Theorem: Finset.norm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rcases s with ⟨⟨l⟩, hl⟩
state_before: α✝ : Type ?u.121829
β : Type ?u.121832
γ : Type ?u.121835
ι : Type u_2
inst✝² : SeminormedRing α✝
α : Type u_1
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
s : Finset ι
f : ι → α
⊢ ‖∏ i in s, f i‖ ≤ ∏ i in s, ‖f i‖

tactic: simpa using (l.map f).norm_prod_le
state_before: case mk.mk
α✝ : Type ?u.121829
β : Type ?u.121832
γ : Type ?u.121835
ι : Type u_2
inst✝² : SeminormedRing α✝
α : Type u_1
inst✝¹ : NormedCommRing α
inst✝ : NormOneClass α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
⊢ ‖∏ i in { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i in { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
Theorem: List.Func.get_add
File: Mathlib/Data/List/Func.lean

tactic: apply @get_pointwise _ _ _ ⟨0⟩ ⟨0⟩ ⟨0⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u
inst✝ : AddMonoid α
k : ℕ
xs ys : List α
⊢ get k (add xs ys) = get k xs + get k ys

tactic: apply zero_add
state_before: case h1
α✝ : Type u
β : Type v
γ : Type w
α : Type u
inst✝ : AddMonoid α
k : ℕ
xs ys : List α
⊢ default + default = default
Theorem: Set.singleton_seq
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.265922
ι : Sort ?u.265925
ι' : Sort ?u.265928
ι₂ : Sort ?u.265931
κ : ι → Sort ?u.265936
κ₁ : ι → Sort ?u.265941
κ₂ : ι → Sort ?u.265946
κ' : ι' → Sort ?u.265951
f : α → β
t : Set α
⊢ ∀ (x : β), x ∈ seq {f} t ↔ x ∈ f '' t
Theorem: openSegment_eq_image
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp only [add_sub_cancel]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.65804
G : Type ?u.65807
ι : Type ?u.65810
π : ι → Type ?u.65815
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
x✝ : z ∈ openSegment 𝕜 x y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • x + b • y = z
⊢ (fun θ => (a + b - θ) • x + θ • y) b = a • x + b • y
Theorem: Real.rpow_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp [rpow_def]
state_before: x : ℝ
⊢ x ^ 0 = 1
Theorem: BoundedContinuousFunction.norm_coe_le_norm
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp [dist_zero_right]
state_before: F : Type ?u.995091
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x✝ : α
C : ℝ
x : α
⊢ ‖↑f x‖ = dist (↑f x) (↑0 x)
Theorem: Polynomial.reverse_mul_of_domain
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: by_cases f0 : f = 0
state_before: R✝ : Type ?u.361245
inst✝² : Semiring R✝
f✝ : R✝[X]
R : Type u_1
inst✝¹ : Ring R
inst✝ : NoZeroDivisors R
f g : R[X]
⊢ reverse (f * g) = reverse f * reverse g

tactic: by_cases g0 : g = 0
state_before: case neg
R✝ : Type ?u.361245
inst✝² : Semiring R✝
f✝ : R✝[X]
R : Type u_1
inst✝¹ : Ring R
inst✝ : NoZeroDivisors R
f g : R[X]
f0 : ¬f = 0
⊢ reverse (f * g) = reverse f * reverse g

tactic: simp [reverse_mul, *]
state_before: case neg
R✝ : Type ?u.361245
inst✝² : Semiring R✝
f✝ : R✝[X]
R : Type u_1
inst✝¹ : Ring R
inst✝ : NoZeroDivisors R
f g : R[X]
f0 : ¬f = 0
g0 : ¬g = 0
⊢ reverse (f * g) = reverse f * reverse g

tactic: simp only [f0, zero_mul, reverse_zero]
state_before: case pos
R✝ : Type ?u.361245
inst✝² : Semiring R✝
f✝ : R✝[X]
R : Type u_1
inst✝¹ : Ring R
inst✝ : NoZeroDivisors R
f g : R[X]
f0 : f = 0
⊢ reverse (f * g) = reverse f * reverse g

tactic: rw [g0, mul_zero, reverse_zero, mul_zero]
state_before: case pos
R✝ : Type ?u.361245
inst✝² : Semiring R✝
f✝ : R✝[X]
R : Type u_1
inst✝¹ : Ring R
inst✝ : NoZeroDivisors R
f g : R[X]
f0 : ¬f = 0
g0 : g = 0
⊢ reverse (f * g) = reverse f * reverse g
Theorem: SimplexCategory.continuous_toTopMap
File: Mathlib/AlgebraicTopology/TopologicalSimplex.lean

tactic: refine' Continuous.subtype_mk (continuous_pi fun i => _) _
state_before: x y : SimplexCategory
f : x ⟶ y
⊢ Continuous (toTopMap f)

tactic: dsimp only [coe_toTopMap]
state_before: x y : SimplexCategory
f : x ⟶ y
i : (CategoryTheory.forget SimplexCategory).obj y
⊢ Continuous fun a =>
    ∑ j in Finset.filter (fun k => (CategoryTheory.forget SimplexCategory).map f k = i) Finset.univ, ↑a j

tactic: exact continuous_finset_sum _ (fun j _ => (continuous_apply _).comp continuous_subtype_val)
state_before: x y : SimplexCategory
f : x ⟶ y
i : (CategoryTheory.forget SimplexCategory).obj y
⊢ Continuous fun a =>
    ∑ j in Finset.filter (fun k => (CategoryTheory.forget SimplexCategory).map f k = i) Finset.univ, ↑a j
Theorem: Behrend.map_monotone
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: dsimp
state_before: α : Type ?u.180760
β : Type ?u.180763
n d✝ k N : ℕ
x✝ : Fin n → ℕ
d : ℕ
x y : Fin n → ℕ
h : x ≤ y
⊢ ↑(map d) x ≤ ↑(map d) y

tactic: exact sum_le_sum fun i _ => Nat.mul_le_mul_right _ <| h i
state_before: α : Type ?u.180760
β : Type ?u.180763
n d✝ k N : ℕ
x✝ : Fin n → ℕ
d : ℕ
x y : Fin n → ℕ
h : x ≤ y
⊢ ∑ i : Fin n, x i * d ^ ↑i ≤ ∑ i : Fin n, y i * d ^ ↑i
Theorem: CategoryTheory.Functor.preservesEpimorphisms.of_iso
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: haveI : Epi (F.map f ≫ (α.app Y).hom) := epi_comp _ _
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : PreservesEpimorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi f
⊢ Epi (G.map f)

tactic: convert (epi_comp _ _ : Epi ((α.app X).inv ≫ F.map f ≫ (α.app Y).hom))
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : PreservesEpimorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi f
this : Epi (F.map f ≫ (α.app Y).hom)
⊢ Epi (G.map f)

tactic: rw [Iso.eq_inv_comp, Iso.app_hom, Iso.app_hom, NatTrans.naturality]
state_before: case h.e'_5
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : PreservesEpimorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi f
this : Epi (F.map f ≫ (α.app Y).hom)
⊢ G.map f = (α.app X).inv ≫ F.map f ≫ (α.app Y).hom
Theorem: Fin.symm_cast
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n m : ℕ
h : n = m
⊢ OrderIso.symm (cast h) = cast (_ : m = n)
Theorem: primorial_succ
File: Mathlib/NumberTheory/Primorial.lean

tactic: refine prod_congr ?_ fun _ _ ↦ rfl
state_before: n : ℕ
hn1 : n ≠ 1
hn : Odd n
⊢ (n + 1)# = n#

tactic: rw [range_succ, filter_insert, if_neg fun h ↦ odd_iff_not_even.mp hn _]
state_before: n : ℕ
hn1 : n ≠ 1
hn : Odd n
⊢ filter Nat.Prime (range (n + 1 + 1)) = filter Nat.Prime (range (n + 1))

tactic: exact fun h ↦ h.even_sub_one <| mt succ.inj hn1
state_before: n : ℕ
hn1 : n ≠ 1
hn : Odd n
⊢ Nat.Prime (n + 1) → Even n
Theorem: CircleDeg1Lift.translationNumber_units_inv
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp [← translationNumber_mul_of_commute (Commute.refl _).units_inv_left]
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
⊢ τ ↑f⁻¹ + τ ↑f = 0