1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AkraBazziRecurrence.strictAntiOn_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: show StrictAntiOn (fun x => 1 / log x) (Set.Ioi 1)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn ε (Set.Ioi 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => 1 / log x) (Set.Ioi 1)

tactic: simp_rw [one_div]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => 1 / log x) (Set.Ioi 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => (log x)⁻¹) (Set.Ioi 1)

tactic: refine StrictAntiOn.comp_strictMonoOn inv_strictAntiOn ?log fun _ hx => log_pos hx
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictAntiOn (fun x => (log x)⁻¹) (Set.Ioi 1)
state_after: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn log (Set.Ioi 1)

tactic: refine StrictMonoOn.mono strictMonoOn_log (fun x hx => ?_)
state_before: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn log (Set.Ioi 1)
state_after: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : x ∈ Set.Ioi 1
⊢ x ∈ Set.Ioi 0

tactic: exact Set.Ioi_subset_Ioi zero_le_one hx
state_before: case log
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : x ∈ Set.Ioi 1
⊢ x ∈ Set.Ioi 0
state_after: no goals
Theorem: zpow_sub_one₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [mul_assoc, mul_inv_cancel ha, mul_one]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
ha : a ≠ 0
n : ℤ
⊢ a ^ (n - 1) = a ^ (n - 1) * a * a⁻¹
state_after: no goals

tactic: rw [← zpow_add_one₀ ha, Int.sub_add_cancel]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
ha : a ≠ 0
n : ℤ
⊢ a ^ (n - 1) * a * a⁻¹ = a ^ n * a⁻¹
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.range_const_subset
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
inst✝ : MeasurableSpace α
b : β
⊢ ↑(const α b).range ⊆ ↑{b}
state_after: no goals
Theorem: CategoryTheory.Localization.natTrans_ext
File: Mathlib/CategoryTheory/Localization/Predicate.lean

tactic: haveI := essSurj L W
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
⊢ τ = τ'
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
this : L.EssSurj
⊢ τ = τ'

tactic: ext Y
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
this : L.EssSurj
⊢ τ = τ'
state_after: case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
this : L.EssSurj
Y : D
⊢ τ.app Y = τ'.app Y

tactic: rw [← cancel_epi (F₁.map (L.objObjPreimageIso Y).hom), τ.naturality, τ'.naturality, h]
state_before: case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
this : L.EssSurj
Y : D
⊢ τ.app Y = τ'.app Y
state_after: no goals
Theorem: Batteries.AssocList.length_replace
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l
state_before: α : Type u_1
β✝ : Type u_2
b : β✝
l : AssocList α β✝
inst✝ : BEq α
a : α
⊢ (replace a b l).length = l.length
state_after: case nil
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a : α
⊢ (replace a b nil).length = nil.length

case cons
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a key✝ : α
value✝ : β✝
tail✝ : AssocList α β✝
tail_ih✝ : (replace a b tail✝).length = tail✝.length
⊢ (replace a b (cons key✝ value✝ tail✝)).length = (cons key✝ value✝ tail✝).length

tactic: rfl
state_before: case nil
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a : α
⊢ (replace a b nil).length = nil.length
state_after: no goals

tactic: simp only [replace, length_cons]
state_before: case cons
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a key✝ : α
value✝ : β✝
tail✝ : AssocList α β✝
tail_ih✝ : (replace a b tail✝).length = tail✝.length
⊢ (replace a b (cons key✝ value✝ tail✝)).length = (cons key✝ value✝ tail✝).length
state_after: case cons
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a key✝ : α
value✝ : β✝
tail✝ : AssocList α β✝
tail_ih✝ : (replace a b tail✝).length = tail✝.length
⊢ (match key✝ == a with
      | true => cons a b tail✝
      | false => cons key✝ value✝ (replace a b tail✝)).length =
    tail✝.length + 1

tactic: split <;> simp_all
state_before: case cons
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a key✝ : α
value✝ : β✝
tail✝ : AssocList α β✝
tail_ih✝ : (replace a b tail✝).length = tail✝.length
⊢ (match key✝ == a with
      | true => cons a b tail✝
      | false => cons key✝ value✝ (replace a b tail✝)).length =
    tail✝.length + 1
state_after: no goals
Theorem: Module.End.hasGenEigenvalue_of_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: apply hasGenEigenvalue_of_hasGenEigenvalue_of_le hk
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : f.HasEigenvalue μ
⊢ f.HasGenEigenvalue μ k
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : f.HasEigenvalue μ
⊢ f.HasGenEigenvalue μ (Nat.succ 0)

tactic: rw [HasGenEigenvalue, genEigenspace, OrderHom.coe_mk, pow_one]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : f.HasEigenvalue μ
⊢ f.HasGenEigenvalue μ (Nat.succ 0)
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : f.HasEigenvalue μ
⊢ LinearMap.ker (f - (algebraMap R (End R M)) μ) ≠ ⊥

tactic: exact hμ
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : f.HasEigenvalue μ
⊢ LinearMap.ker (f - (algebraMap R (End R M)) μ) ≠ ⊥
state_after: no goals
Theorem: Finset.prod_nonneg_of_card_nonpos_even
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: split_ifs with hx
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
⊢ 0 ≤ (if f x ≤ 0 then -1 else 1) * f x
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : f x ≤ 0
⊢ 0 ≤ -1 * f x

case neg
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : ¬f x ≤ 0
⊢ 0 ≤ 1 * f x

tactic: simp? at hx ⊢ says simp only [not_le, one_mul] at hx ⊢
state_before: case neg
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : ¬f x ≤ 0
⊢ 0 ≤ 1 * f x
state_after: case neg
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : 0 < f x
⊢ 0 ≤ f x

tactic: exact le_of_lt hx
state_before: case neg
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : 0 < f x
⊢ 0 ≤ f x
state_after: no goals

tactic: simp [hx]
state_before: case pos
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : f x ≤ 0
⊢ 0 ≤ -1 * f x
state_after: no goals

tactic: simp only [not_le, one_mul] at hx ⊢
state_before: case neg
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : ¬f x ≤ 0
⊢ 0 ≤ 1 * f x
state_after: case neg
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
x : α
x✝ : x ∈ s
hx : 0 < f x
⊢ 0 ≤ f x

tactic: rw [Finset.prod_mul_distrib, Finset.prod_ite, Finset.prod_const_one, mul_one,
  Finset.prod_const, neg_one_pow_eq_pow_mod_two, Nat.even_iff.1 h0, pow_zero, one_mul]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (filter (fun x => f x ≤ 0) s).card
⊢ ∏ x ∈ s, (if f x ≤ 0 then -1 else 1) * f x = ∏ x ∈ s, f x
state_after: no goals
Theorem: Finset.filter_union
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_filter, mem_union, or_and_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s : Finset α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
x✝ : α
⊢ x✝ ∈ filter p (s₁ ∪ s₂) ↔ x✝ ∈ filter p s₁ ∪ filter p s₂
state_after: no goals
Theorem: ProbabilityTheory.kernel.compProd_fst_condKernelBorel
File: Mathlib/Probability/Kernel/Disintegration/Basic.lean

tactic: rw [condKernelBorel, compProd_fst_borelMarkovFromReal _ _ (compProd_fst_condKernelReal _)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel α (γ × Ω))
inst✝ : IsFiniteKernel κ
⊢ fst κ ⊗ₖ condKernelBorel κ = κ
state_after: no goals
Theorem: CategoryTheory.ShortComplex.homologyπ_comp_leftHomologyIso_inv
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: dsimp only [homologyπ]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ S.homologyπ ≫ S.leftHomologyIso.inv = S.leftHomologyπ
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ (S.leftHomologyπ ≫ S.leftHomologyIso.hom) ≫ S.leftHomologyIso.inv = S.leftHomologyπ

tactic: simp only [assoc, Iso.hom_inv_id, comp_id]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ (S.leftHomologyπ ≫ S.leftHomologyIso.hom) ≫ S.leftHomologyIso.inv = S.leftHomologyπ
state_after: no goals
Theorem: sub_inv_antitoneOn_Icc_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: by_cases hab : a ≤ b
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : b < c
⊢ AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : b < c
hab : a ≤ b
⊢ AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : b < c
hab : ¬a ≤ b
⊢ AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)

tactic: exact sub_inv_antitoneOn_Iio.mono <| (Set.Icc_subset_Iio_iff hab).mpr ha
state_before: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : b < c
hab : a ≤ b
⊢ AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)
state_after: no goals

tactic: simp [hab, Set.Subsingleton.antitoneOn]
state_before: case neg
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : b < c
hab : ¬a ≤ b
⊢ AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)
state_after: no goals
Theorem: Algebra.mem_iInf
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
ι : Sort u_1
S : ι → Subalgebra R A
x : A
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
Theorem: EuclideanSpace.single_apply
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: rw [EuclideanSpace.single, WithLp.equiv_symm_pi_apply, ← Pi.single_apply i a j]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : DecidableEq ι
i : ι
a : 𝕜
j : ι
⊢ single i a j = if j = i then a else 0
state_after: no goals
Theorem: Set.preimage_swap_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
⊢ Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
x : β
y : α
⊢ (x, y) ∈ Prod.swap ⁻¹' s ×ˢ t ↔ (x, y) ∈ t ×ˢ s

tactic: simp [and_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
x : β
y : α
⊢ (x, y) ∈ Prod.swap ⁻¹' s ×ˢ t ↔ (x, y) ∈ t ×ˢ s
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.trim_eq_self
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext i hi
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
⊢ v.trim ⋯ = v
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(v.trim ⋯) i = ↑v i

tactic: exact if_pos hi
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(v.trim ⋯) i = ↑v i
state_after: no goals
Theorem: Filter.tendsto_const_mul_atTop_iff_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [tendsto_const_mul_atTop_iff, h, h.not_tendsto disjoint_atBot_atTop]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : l.NeBot
h : Tendsto f l atBot
⊢ Tendsto (fun x => r * f x) l atTop ↔ r < 0
state_after: no goals
Theorem: Nat.xor_eq_zero
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [← xor_self n, xor_right_inj, eq_comm]
state_before: n m : ℕ
⊢ n ^^^ m = 0 ↔ n = m
state_after: no goals
Theorem: PNat.mod_coe
File: Mathlib/Data/PNat/Defs.lean

tactic: dsimp [mod, modDiv]
state_before: m k : ℕ+
⊢ ↑(m.mod k) = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k
state_after: m k : ℕ+
⊢ ↑(k.modDivAux (↑m % ↑k) (↑m / ↑k)).1 = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k

tactic: cases (m : ℕ) % (k : ℕ) with
| zero =>
  rw [if_pos rfl]
  rfl
| succ n =>
  rw [if_neg n.succ_ne_zero]
  rfl
state_before: m k : ℕ+
⊢ ↑(k.modDivAux (↑m % ↑k) (↑m / ↑k)).1 = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k
state_after: no goals

tactic: rw [if_pos rfl]
state_before: case zero
m k : ℕ+
⊢ ↑(k.modDivAux 0 (↑m / ↑k)).1 = if 0 = 0 then ↑k else 0
state_after: case zero
m k : ℕ+
⊢ ↑(k.modDivAux 0 (↑m / ↑k)).1 = ↑k

tactic: rfl
state_before: case zero
m k : ℕ+
⊢ ↑(k.modDivAux 0 (↑m / ↑k)).1 = ↑k
state_after: no goals

tactic: rw [if_neg n.succ_ne_zero]
state_before: case succ
m k : ℕ+
n : ℕ
⊢ ↑(k.modDivAux (n + 1) (↑m / ↑k)).1 = if n + 1 = 0 then ↑k else n + 1
state_after: case succ
m k : ℕ+
n : ℕ
⊢ ↑(k.modDivAux (n + 1) (↑m / ↑k)).1 = n + 1

tactic: rfl
state_before: case succ
m k : ℕ+
n : ℕ
⊢ ↑(k.modDivAux (n + 1) (↑m / ↑k)).1 = n + 1
state_after: no goals
Theorem: contDiff_one_iff_hasFDerivAt
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: convert contDiff_succ_iff_hasFDerivAt using 4
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiff 𝕜 1 f ↔ ∃ f', Continuous f' ∧ ∀ (x : E), HasFDerivAt f (f' x) x
state_after: case h.e'_2.h.e'_2.h.h.e'_1.a
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
x✝ : E → E →L[𝕜] F
⊢ Continuous x✝ ↔ ContDiff 𝕜 (↑Nat.zero) x✝

tactic: simp
state_before: case h.e'_2.h.e'_2.h.h.e'_1.a
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
x✝ : E → E →L[𝕜] F
⊢ Continuous x✝ ↔ ContDiff 𝕜 (↑Nat.zero) x✝
state_after: no goals
Theorem: CategoryTheory.Functor.initial_of_adjunction
File: Mathlib/CategoryTheory/Limits/Final.lean

tactic: simp [u]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
d : D
u : CostructuredArrow L d := CostructuredArrow.mk (adj.counit.app d)
f g : CostructuredArrow L d
⊢ L.map ((adj.homEquiv f.left d) f.hom) ≫ u.hom = f.hom
state_after: no goals

tactic: simp [u]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
d : D
u : CostructuredArrow L d := CostructuredArrow.mk (adj.counit.app d)
f g : CostructuredArrow L d
⊢ L.map ((adj.homEquiv g.left d) g.hom) ≫ u.hom = g.hom
state_after: no goals
Theorem: Int.natCast_ne_zero_iff_pos
File: Mathlib/Data/Int/Defs.lean

tactic: omega
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑n ≠ 0 ↔ 0 < n
state_after: no goals
Theorem: Polynomial.degree_monomial
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [degree, support_monomial n ha, max_singleton, Nat.cast_withBot]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
ha : a ≠ 0
⊢ ((monomial n) a).degree = ↑n
state_after: no goals
Theorem: Affine.Simplex.sum_pointWeightsWithCircumcenter
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

tactic: convert sum_ite_eq' univ (pointIndex i) (Function.const _ (1 : ℝ)) with j
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
⊢ ∑ j : PointsWithCircumcenterIndex n, pointWeightsWithCircumcenter i j = 1
state_after: case h.e'_2.a
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
j : PointsWithCircumcenterIndex n
a✝ : j ∈ univ
⊢ pointWeightsWithCircumcenter i j = if j = pointIndex i then Function.const (PointsWithCircumcenterIndex n) 1 j else 0

case h.e'_3
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
⊢ 1 = if pointIndex i ∈ univ then Function.const (PointsWithCircumcenterIndex n) 1 (pointIndex i) else 0

tactic: cases j <;> simp [pointWeightsWithCircumcenter]
state_before: case h.e'_2.a
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
j : PointsWithCircumcenterIndex n
a✝ : j ∈ univ
⊢ pointWeightsWithCircumcenter i j = if j = pointIndex i then Function.const (PointsWithCircumcenterIndex n) 1 j else 0
state_after: no goals

tactic: simp
state_before: case h.e'_3
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i : Fin (n + 1)
⊢ 1 = if pointIndex i ∈ univ then Function.const (PointsWithCircumcenterIndex n) 1 (pointIndex i) else 0
state_after: no goals