1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: PartENat.card_eq_zero_iff_empty
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: rw [← Cardinal.mk_eq_zero_iff]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ IsEmpty α
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ #α = 0

tactic: conv_rhs => rw [← Nat.cast_zero]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ #α = 0
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ #α = ↑0

tactic: simp only [← Cardinal.toPartENat_eq_natCast_iff]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ #α = ↑0
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ toPartENat #α = ↑0

tactic: simp only [PartENat.card, Nat.cast_zero]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α = 0 ↔ toPartENat #α = ↑0
state_after: no goals
Theorem: CategoryTheory.Subobject.mk_le_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X : Subobject B
f : A ⟶ B
inst✝ : Mono f
g : A ⟶ underlying.obj X
w : g ≫ X.arrow = f
⊢ ((underlyingIso f).hom ≫ g) ≫ X.arrow = (mk f).arrow
state_after: no goals
Theorem: Equiv.Perm.extendDomain_trans
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [Perm.extendDomain, permCongr_trans]
state_before: α' : Type u_1
β' : Type u_2
e✝ : Perm α'
p : β' → Prop
inst✝ : DecidablePred p
f : α' ≃ Subtype p
e e' : Perm α'
⊢ Equiv.trans (e.extendDomain f) (e'.extendDomain f) = extendDomain (Equiv.trans e e') f
state_after: no goals
Theorem: Real.abs_cos_le_one
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp only [← sq, cos_sq_le_one]
state_before: x y : ℝ
⊢ cos x * cos x ≤ 1
state_after: no goals
Theorem: Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_le, ← not_le, not_iff_not, cos_nonneg_iff_abs_toReal_le_pi_div_two]
state_before: θ : Angle
⊢ θ.cos < 0 ↔ π / 2 < |θ.toReal|
state_after: no goals
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow'
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [equalizerSubobjectIso]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ (equalizerSubobjectIso f g).inv ≫ (equalizerSubobject f g).arrow = equalizer.ι f g
state_after: no goals
Theorem: separableClosure.map_eq_of_separableClosure_eq_bot
File: Mathlib/FieldTheory/SeparableClosure.lean

tactic: refine le_antisymm (map_le_of_algHom _) (fun x hx ↦ ?_)
state_before: F : Type u
E : Type v
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
K : Type w
inst✝³ : Field K
inst✝² : Algebra F K
inst✝¹ : Algebra E K
inst✝ : IsScalarTower F E K
h : separableClosure E K = ⊥
⊢ IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E) = separableClosure F K
state_after: F : Type u
E : Type v
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
K : Type w
inst✝³ : Field K
inst✝² : Algebra F K
inst✝¹ : Algebra E K
inst✝ : IsScalarTower F E K
h : separableClosure E K = ⊥
x : K
hx : x ∈ separableClosure F K
⊢ x ∈ IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E)

tactic: obtain ⟨y, rfl⟩ := mem_bot.1 <| h ▸ mem_separableClosure_iff.2
  (mem_separableClosure_iff.1 hx |>.map_minpoly E)
state_before: F : Type u
E : Type v
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
K : Type w
inst✝³ : Field K
inst✝² : Algebra F K
inst✝¹ : Algebra E K
inst✝ : IsScalarTower F E K
h : separableClosure E K = ⊥
x : K
hx : x ∈ separableClosure F K
⊢ x ∈ IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E)
state_after: case intro
F : Type u
E : Type v
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
K : Type w
inst✝³ : Field K
inst✝² : Algebra F K
inst✝¹ : Algebra E K
inst✝ : IsScalarTower F E K
h : separableClosure E K = ⊥
y : E
hx : (algebraMap E K) y ∈ separableClosure F K
⊢ (algebraMap E K) y ∈ IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E)

tactic: exact ⟨y, (map_mem_separableClosure_iff <| IsScalarTower.toAlgHom F E K).mp hx, rfl⟩
state_before: case intro
F : Type u
E : Type v
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
K : Type w
inst✝³ : Field K
inst✝² : Algebra F K
inst✝¹ : Algebra E K
inst✝ : IsScalarTower F E K
h : separableClosure E K = ⊥
y : E
hx : (algebraMap E K) y ∈ separableClosure F K
⊢ (algebraMap E K) y ∈ IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E)
state_after: no goals
Theorem: MeasureTheory.lintegral_div_right_eq_self
File: Mathlib/MeasureTheory/Group/LIntegral.lean

tactic: simp_rw [div_eq_mul_inv, lintegral_mul_right_eq_self f g⁻¹]
state_before: G : Type u_1
inst✝³ : MeasurableSpace G
μ : Measure G
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → ℝ≥0∞
g : G
⊢ ∫⁻ (x : G), f (x / g) ∂μ = ∫⁻ (x : G), f x ∂μ
state_after: no goals
Theorem: Module.Dual.finrank_ker_add_one_of_ne_zero
File: Mathlib/LinearAlgebra/Dual.lean

tactic: suffices finrank K (LinearMap.range f) = 1 by
  rw [← (LinearMap.ker f).finrank_quotient_add_finrank, add_comm, add_left_inj,
  f.quotKerEquivRange.finrank_eq, this]
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
⊢ finrank K ↥(LinearMap.ker f) + 1 = finrank K V₁
state_after: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
⊢ finrank K ↥(LinearMap.range f) = 1

tactic: rw [range_eq_top_of_ne_zero hf, finrank_top, finrank_self]
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
⊢ finrank K ↥(LinearMap.range f) = 1
state_after: no goals

tactic: rw [← (LinearMap.ker f).finrank_quotient_add_finrank, add_comm, add_left_inj,
f.quotKerEquivRange.finrank_eq, this]
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V₁
f : Dual K V₁
hf : f ≠ 0
this : finrank K ↥(LinearMap.range f) = 1
⊢ finrank K ↥(LinearMap.ker f) + 1 = finrank K V₁
state_after: no goals
Theorem: CategoryTheory.Functor.OfSequence.map_id
File: Mathlib/CategoryTheory/Functor/OfSequence.lean

tactic: omega
state_before: C : Type u_1
inst✝ : Category.{?u.3028, u_1} C
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
i : ℕ
⊢ i ≤ i
state_after: no goals

tactic: revert X f
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
i : ℕ
⊢ map f i i ⋯ = 𝟙 (X i)
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
i : ℕ
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f i i ⋯ = 𝟙 (X i)

tactic: induction i with
| zero => intros; rfl
| succ _ hi =>
    intro X f
    apply hi
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
i : ℕ
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f i i ⋯ = 𝟙 (X i)
state_after: no goals

tactic: intros
state_before: case zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f 0 0 ⋯ = 𝟙 (X 0)
state_after: case zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X✝ : ℕ → C
f✝ : (n : ℕ) → X✝ n ⟶ X✝ (n + 1)
⊢ map f✝ 0 0 ⋯ = 𝟙 (X✝ 0)

tactic: rfl
state_before: case zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X✝ : ℕ → C
f✝ : (n : ℕ) → X✝ n ⟶ X✝ (n + 1)
⊢ map f✝ 0 0 ⋯ = 𝟙 (X✝ 0)
state_after: no goals

tactic: intro X f
state_before: case succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n✝ : ℕ
hi : ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f n✝ n✝ ⋯ = 𝟙 (X n✝)
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f (n✝ + 1) (n✝ + 1) ⋯ = 𝟙 (X (n✝ + 1))
state_after: case succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n✝ : ℕ
hi : ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f n✝ n✝ ⋯ = 𝟙 (X n✝)
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
⊢ map f (n✝ + 1) (n✝ + 1) ⋯ = 𝟙 (X (n✝ + 1))

tactic: apply hi
state_before: case succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n✝ : ℕ
hi : ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f n✝ n✝ ⋯ = 𝟙 (X n✝)
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
⊢ map f (n✝ + 1) (n✝ + 1) ⋯ = 𝟙 (X (n✝ + 1))
state_after: no goals
Theorem: Nat.frequently_atTop_iff_infinite
File: Mathlib/Order/Filter/Cofinite.lean

tactic: rw [← Nat.cofinite_eq_atTop, frequently_cofinite_iff_infinite]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
p : ℕ → Prop
⊢ (∃ᶠ (n : ℕ) in atTop, p n) ↔ {n | p n}.Infinite
state_after: no goals
Theorem: String.toList_nonempty
File: Mathlib/Data/String/Basic.lean

tactic: cases s with
| nil => simp at h
| cons c cs =>
  simp only [toList, data_drop, List.drop_succ_cons, List.drop_zero, List.cons.injEq, and_true]
  rfl
state_before: s : List Char
h : { data := s } ≠ ""
⊢ { data := s }.toList = { data := s }.head :: ({ data := s }.drop 1).toList
state_after: no goals

tactic: simp at h
state_before: case nil
h : { data := [] } ≠ ""
⊢ { data := [] }.toList = { data := [] }.head :: ({ data := [] }.drop 1).toList
state_after: no goals

tactic: simp only [toList, data_drop, List.drop_succ_cons, List.drop_zero, List.cons.injEq, and_true]
state_before: case cons
c : Char
cs : List Char
h : { data := c :: cs } ≠ ""
⊢ { data := c :: cs }.toList = { data := c :: cs }.head :: ({ data := c :: cs }.drop 1).toList
state_after: case cons
c : Char
cs : List Char
h : { data := c :: cs } ≠ ""
⊢ c = { data := c :: cs }.head

tactic: rfl
state_before: case cons
c : Char
cs : List Char
h : { data := c :: cs } ≠ ""
⊢ c = { data := c :: cs }.head
state_after: no goals
Theorem: lp.norm_eq_tsum_rpow
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: dsimp [norm]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ ‖f‖ = (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ (if hp : p = 0 then Eq.rec (motive := fun x x_1 => ↥(lp E x) → ℝ) (fun f => ↑⋯.toFinset.card) ⋯ f
    else if p = ⊤ then ⨆ i, ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)) =
    (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)

tactic: rw [ENNReal.toReal_pos_iff] at hp
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p.toReal
f : ↥(lp E p)
⊢ (if hp : p = 0 then Eq.rec (motive := fun x x_1 => ↥(lp E x) → ℝ) (fun f => ↑⋯.toFinset.card) ⋯ f
    else if p = ⊤ then ⨆ i, ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)) =
    (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p ∧ p < ⊤
f : ↥(lp E p)
⊢ (if hp : p = 0 then Eq.rec (motive := fun x x_1 => ↥(lp E x) → ℝ) (fun f => ↑⋯.toFinset.card) ⋯ f
    else if p = ⊤ then ⨆ i, ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)) =
    (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)

tactic: rw [dif_neg hp.1.ne', if_neg hp.2.ne]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p ∧ p < ⊤
f : ↥(lp E p)
⊢ (if hp : p = 0 then Eq.rec (motive := fun x x_1 => ↥(lp E x) → ℝ) (fun f => ↑⋯.toFinset.card) ⋯ f
    else if p = ⊤ then ⨆ i, ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)) =
    (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)
state_after: no goals
Theorem: Polynomial.coeff_zero_eq_aeval_zero
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

tactic: simp [coeff_zero_eq_eval_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : CommSemiring A'
inst✝³ : Semiring B
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R B
p✝ q : R[X]
x : A
p : R[X]
⊢ p.coeff 0 = (aeval 0) p
state_after: no goals
Theorem: MeasureTheory.Integrable.hasSum_intervalIntegral
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp_rw [integral_of_le (le_add_of_nonneg_right zero_le_one)]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : Measure ℝ
f : ℝ → E
hfi : Integrable f μ
y : ℝ
⊢ HasSum (fun n => ∫ (x : ℝ) in y + ↑n..y + ↑n + 1, f x ∂μ) (∫ (x : ℝ), f x ∂μ)
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : Measure ℝ
f : ℝ → E
hfi : Integrable f μ
y : ℝ
⊢ HasSum (fun n => ∫ (x : ℝ) in Ioc (y + ↑n) (y + ↑n + 1), f x ∂μ) (∫ (x : ℝ), f x ∂μ)

tactic: rw [← integral_univ, ← iUnion_Ioc_add_intCast y]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : Measure ℝ
f : ℝ → E
hfi : Integrable f μ
y : ℝ
⊢ HasSum (fun n => ∫ (x : ℝ) in Ioc (y + ↑n) (y + ↑n + 1), f x ∂μ) (∫ (x : ℝ), f x ∂μ)
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : Measure ℝ
f : ℝ → E
hfi : Integrable f μ
y : ℝ
⊢ HasSum (fun n => ∫ (x : ℝ) in Ioc (y + ↑n) (y + ↑n + 1), f x ∂μ) (∫ (x : ℝ) in ⋃ n, Ioc (y + ↑n) (y + ↑n + 1), f x ∂μ)

tactic: exact
  hasSum_integral_iUnion (fun i => measurableSet_Ioc) (pairwise_disjoint_Ioc_add_intCast y)
    hfi.integrableOn
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : Measure ℝ
f : ℝ → E
hfi : Integrable f μ
y : ℝ
⊢ HasSum (fun n => ∫ (x : ℝ) in Ioc (y + ↑n) (y + ↑n + 1), f x ∂μ) (∫ (x : ℝ) in ⋃ n, Ioc (y + ↑n) (y + ↑n + 1), f x ∂μ)
state_after: no goals
Theorem: FreeAbelianGroup.support_nsmul
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: apply support_zsmul k _ a
state_before: X : Type u_1
k : ℕ
h : k ≠ 0
a : FreeAbelianGroup X
⊢ (k • a).support = a.support
state_after: X : Type u_1
k : ℕ
h : k ≠ 0
a : FreeAbelianGroup X
⊢ ↑k ≠ 0

tactic: exact mod_cast h
state_before: X : Type u_1
k : ℕ
h : k ≠ 0
a : FreeAbelianGroup X
⊢ ↑k ≠ 0
state_after: no goals
Theorem: CategoryTheory.Limits.Types.pi_map_π_apply'
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

tactic: simp
state_before: β : Type v
f g : β → Type v
α : (j : β) → f j ⟶ g j
b : β
x : ∏ᶜ f
⊢ Pi.π g b (Pi.map α x) = α b (Pi.π f b x)
state_after: no goals
Theorem: Finset.truncatedInf_of_isAntichain
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

tactic: refine le_antisymm truncatedInf_le ?_
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
⊢ s.truncatedInf a = a
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
⊢ a ≤ s.truncatedInf a

tactic: simp_rw [truncatedInf_of_mem (subset_upperClosure ha), le_inf'_iff, mem_filter]
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
⊢ a ≤ s.truncatedInf a
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
⊢ ∀ (b : α), b ∈ s ∧ b ≤ a → a ≤ id b

tactic: rintro b ⟨hb, hba⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
⊢ ∀ (b : α), b ∈ s ∧ b ≤ a → a ≤ id b
state_after: case intro
α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
b : α
hb : b ∈ s
hba : b ≤ a
⊢ a ≤ id b

tactic: exact (hs.eq hb ha hba).ge
state_before: case intro
α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : IsAntichain (fun x x_1 => x ≤ x_1) ↑s
ha : a ∈ s
b : α
hb : b ∈ s
hba : b ≤ a
⊢ a ≤ id b
state_after: no goals
Theorem: Set.image_symmDiff
File: Mathlib/Data/Set/Image.lean

tactic: simp_rw [Set.symmDiff_def, image_union, image_diff hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s✝ t✝ : Set α
hf : Injective f
s t : Set α
⊢ f '' s ∆ t = (f '' s) ∆ (f '' t)
state_after: no goals
Theorem: FreeAbelianGroup.map_id_apply
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: rw [map_id]
state_before: α : Type u
β : Type v
γ : Type w
x : FreeAbelianGroup α
⊢ (map id) x = x
state_after: α : Type u
β : Type v
γ : Type w
x : FreeAbelianGroup α
⊢ (AddMonoidHom.id (FreeAbelianGroup α)) x = x

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
x : FreeAbelianGroup α
⊢ (AddMonoidHom.id (FreeAbelianGroup α)) x = x
state_after: no goals
Theorem: AntilipschitzWith.le_mul_norm_div
File: Mathlib/Analysis/Normed/Group/Uniform.lean

tactic: simp [← dist_eq_norm_div, hf.le_mul_dist x y]
state_before: 𝓕 : Type u_1
α✝ : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝³ : SeminormedCommGroup E✝
inst✝² : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E✝
r r₁ r₂ : ℝ
α : Type u_5
E : Type u_6
inst✝¹ : SeminormedCommGroup E
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f✝ g : α → E
s : Set α
x✝ : α
f : E → F
hf : AntilipschitzWith K f
x y : E
⊢ ‖x / y‖ ≤ ↑K * ‖f x / f y‖
state_after: no goals
Theorem: NonUnitalCommRing.toNonUnitalRing_injective
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro ⟨⟩ ⟨⟩ _
state_before: R : Type u
⊢ Function.Injective (@toNonUnitalRing R)
state_after: case mk.mk
R : Type u
toNonUnitalRing✝¹ : NonUnitalRing R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toNonUnitalRing✝ : NonUnitalRing R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toNonUnitalRing = toNonUnitalRing
⊢ mk mul_comm✝¹ = mk mul_comm✝

tactic: congr
state_before: case mk.mk
R : Type u
toNonUnitalRing✝¹ : NonUnitalRing R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toNonUnitalRing✝ : NonUnitalRing R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toNonUnitalRing = toNonUnitalRing
⊢ mk mul_comm✝¹ = mk mul_comm✝
state_after: no goals
Theorem: WeierstrassCurve.Affine.equation_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: rw [equation_iff', sub_eq_zero]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x y ↔ y ^ 2 + W.a₁ * x * y + W.a₃ * y = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆
state_after: no goals
Theorem: SimpleGraph.Walk.toSubgraph_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*, Subgraph.map_sup]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
f : G →g G'
p : G.Walk u v
⊢ (Walk.map f p).toSubgraph = Subgraph.map f p.toSubgraph
state_after: no goals
Theorem: ContextFreeGrammar.reverse_mem_language_of_mem_reverse_language
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: convert g.reverse_derives hgw
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hgw : w ∈ g.reverse.language
⊢ w.reverse ∈ g.language
state_after: case a
T : Type uT
g : ContextFreeGrammar T
w : List T
hgw : w ∈ g.reverse.language
⊢ w.reverse ∈ g.language ↔ g.Derives [Symbol.nonterminal g.initial] (List.map Symbol.terminal w).reverse

tactic: simp [List.map_reverse]
state_before: case a
T : Type uT
g : ContextFreeGrammar T
w : List T
hgw : w ∈ g.reverse.language
⊢ w.reverse ∈ g.language ↔ g.Derives [Symbol.nonterminal g.initial] (List.map Symbol.terminal w).reverse
state_after: no goals
Theorem: EReal.mul_div
File: Mathlib/Data/Real/EReal.lean

tactic: change a * (b * c⁻¹) = (a * b) * c⁻¹
state_before: a b c : EReal
⊢ a * (b / c) = a * b / c
state_after: a b c : EReal
⊢ a * (b * c⁻¹) = a * b * c⁻¹

tactic: rw [mul_assoc]
state_before: a b c : EReal
⊢ a * (b * c⁻¹) = a * b * c⁻¹
state_after: no goals
Theorem: Real.eulerMascheroniSeq'_one
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

tactic: simp [eulerMascheroniSeq']
state_before: ⊢ eulerMascheroniSeq' 1 = 1
state_after: no goals
Theorem: Batteries.RBNode.All.reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: induction t <;> simp [*, and_comm]
state_before: α : Type u_1
p : α → Prop
t : RBNode α
⊢ All p t.reverse ↔ All p t
state_after: no goals
Theorem: Set.Nontrivial.infsep_of_fintype
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : s.Nontrivial
⊢ s.offDiag.toFinset.Nonempty
state_after: no goals

tactic: classical rw [Set.infsep_of_fintype, dif_pos hs]
state_before: α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : s.Nontrivial
⊢ s.infsep = s.offDiag.toFinset.inf' ⋯ (uncurry dist)
state_after: no goals

tactic: rw [Set.infsep_of_fintype, dif_pos hs]
state_before: α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : s.Nontrivial
⊢ s.infsep = s.offDiag.toFinset.inf' ⋯ (uncurry dist)
state_after: no goals