1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.eq_of_sigmaMk_comp
File: Mathlib/Data/Sigma/Basic.lean

tactic: rcases ‹Nonempty γ› with ⟨i⟩
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a b : α
f : γ → β a
g : γ → β b
h : mk a ∘ f = mk b ∘ g
⊢ a = b ∧ HEq f g
state_after: case intro
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a b : α
f : γ → β a
g : γ → β b
h : mk a ∘ f = mk b ∘ g
i : γ
⊢ a = b ∧ HEq f g

tactic: obtain rfl : a = b := congr_arg Sigma.fst (congr_fun h i)
state_before: case intro
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a b : α
f : γ → β a
g : γ → β b
h : mk a ∘ f = mk b ∘ g
i : γ
⊢ a = b ∧ HEq f g
state_after: case intro
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a : α
f : γ → β a
i : γ
g : γ → β a
h : mk a ∘ f = mk a ∘ g
⊢ a = a ∧ HEq f g

tactic: simpa [funext_iff] using h
state_before: case intro
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a : α
f : γ → β a
i : γ
g : γ → β a
h : mk a ∘ f = mk a ∘ g
⊢ a = a ∧ HEq f g
state_after: no goals
Theorem: Even.zpow_nonneg
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: obtain ⟨k, rfl⟩ := hn
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d : α
n : ℤ
hn : Even n
a : α
⊢ 0 ≤ a ^ n
state_after: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ (k + k)

tactic: rw [zpow_add' (by simp [em'])]
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ (k + k)
state_after: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ k * a ^ k

tactic: exact mul_self_nonneg _
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ k * a ^ k
state_after: no goals

tactic: simp [em']
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ a ≠ 0 ∨ k + k ≠ 0 ∨ k = 0 ∧ k = 0
state_after: no goals
Theorem: FirstOrder.Language.card_eq_card_functions_add_card_relations
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [card, Symbols]
state_before: L : Language
L' : Language
⊢ L.card = (sum fun l => lift.{v, u} #(L.Functions l)) + sum fun l => lift.{u, v} #(L.Relations l)
state_after: no goals
Theorem: Disjoint.map_orderIso
File: Mathlib/Order/Hom/Basic.lean

tactic: rw [disjoint_iff_inf_le, ← f.map_inf, ← f.map_bot]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : SemilatticeInf α
inst✝² : OrderBot α
inst✝¹ : SemilatticeInf β
inst✝ : OrderBot β
a b : α
f : α ≃o β
ha : Disjoint a b
⊢ Disjoint (f a) (f b)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : SemilatticeInf α
inst✝² : OrderBot α
inst✝¹ : SemilatticeInf β
inst✝ : OrderBot β
a b : α
f : α ≃o β
ha : Disjoint a b
⊢ f (a ⊓ b) ≤ f ⊥

tactic: exact f.monotone ha.le_bot
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : SemilatticeInf α
inst✝² : OrderBot α
inst✝¹ : SemilatticeInf β
inst✝ : OrderBot β
a b : α
f : α ≃o β
ha : Disjoint a b
⊢ f (a ⊓ b) ≤ f ⊥
state_after: no goals
Theorem: frontier_closedBall'
File: Mathlib/Analysis/NormedSpace/Real.lean

tactic: rw [frontier, closure_closedBall, interior_closedBall' x r, closedBall_diff_ball]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ frontier (closedBall x r) = sphere x r
state_after: no goals
Theorem: CliffordAlgebra.toEven_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

tactic: rw [toEven, CliffordAlgebra.lift_ι_apply]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((toEven Q) ((ι Q) m)) = e0 Q * (v Q) m
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((LinearMap.codRestrict (evenOdd (Q' Q) 0) (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) ⋯) m) = e0 Q * (v Q) m

tactic: erw [LinearMap.codRestrict_apply]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((LinearMap.codRestrict (evenOdd (Q' Q) 0) (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) ⋯) m) = e0 Q * (v Q) m
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) m = e0 Q * (v Q) m

tactic: rw [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulLeft_apply]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) m = e0 Q * (v Q) m
state_after: no goals
Theorem: Polynomial.leadingCoeff_ne_zero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [Ne, leadingCoeff_eq_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
⊢ p.leadingCoeff ≠ 0 ↔ p ≠ 0
state_after: no goals
Theorem: Polynomial.lifts_iff_liftsRing
File: Mathlib/Algebra/Polynomial/Lifts.lean

tactic: simp only [lifts, liftsRing, RingHom.mem_range, RingHom.mem_rangeS]
state_before: R : Type u
inst✝¹ : Ring R
S : Type v
inst✝ : Ring S
f : R →+* S
p : S[X]
⊢ p ∈ lifts f ↔ p ∈ liftsRing f
state_after: no goals
Theorem: List.Subperm.exists_of_length_lt
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: obtain ⟨l, p, s⟩ := s
state_before: α : Type u_1
l₁ l₂ : List α
s : l₁ <+~ l₂
h : l₁.length < l₂.length
⊢ ∃ a, a :: l₁ <+~ l₂
state_after: case intro.intro
α : Type u_1
l₁ l₂ : List α
h : l₁.length < l₂.length
l : List α
p : l ~ l₁
s : l <+ l₂
⊢ ∃ a, a :: l₁ <+~ l₂

tactic: suffices length l < length l₂ → ∃ a : α, a :: l <+~ l₂ from
  (this <| p.symm.length_eq ▸ h).imp fun a => (p.cons a).subperm_right.1
state_before: case intro.intro
α : Type u_1
l₁ l₂ : List α
h : l₁.length < l₂.length
l : List α
p : l ~ l₁
s : l <+ l₂
⊢ ∃ a, a :: l₁ <+~ l₂
state_after: case intro.intro
α : Type u_1
l₁ l₂ : List α
h : l₁.length < l₂.length
l : List α
p : l ~ l₁
s : l <+ l₂
⊢ l.length < l₂.length → ∃ a, a :: l <+~ l₂

tactic: clear h p l₁
state_before: case intro.intro
α : Type u_1
l₁ l₂ : List α
h : l₁.length < l₂.length
l : List α
p : l ~ l₁
s : l <+ l₂
⊢ l.length < l₂.length → ∃ a, a :: l <+~ l₂
state_after: case intro.intro
α : Type u_1
l₂ l : List α
s : l <+ l₂
⊢ l.length < l₂.length → ∃ a, a :: l <+~ l₂

tactic: induction s with intro h
| slnil => cases h
| cons a s IH =>
  match Nat.lt_or_eq_of_le (Nat.le_of_lt_succ h) with
  | .inl h => exact (IH h).imp fun a s => s.trans (sublist_cons _ _).subperm
  | .inr h => exact ⟨a, s.eq_of_length h ▸ .refl _⟩
| cons₂ b _ IH =>
  exact (IH <| Nat.lt_of_succ_lt_succ h).imp fun a s =>
    (swap ..).subperm_right.1 <| (subperm_cons _).2 s
state_before: case intro.intro
α : Type u_1
l₂ l : List α
s : l <+ l₂
⊢ l.length < l₂.length → ∃ a, a :: l <+~ l₂
state_after: no goals

tactic: cases h
state_before: case intro.intro.slnil
α : Type u_1
l₂ l : List α
h : [].length < [].length
⊢ ∃ a, [a] <+~ []
state_after: no goals

tactic: match Nat.lt_or_eq_of_le (Nat.le_of_lt_succ h) with
| .inl h => exact (IH h).imp fun a s => s.trans (sublist_cons _ _).subperm
| .inr h => exact ⟨a, s.eq_of_length h ▸ .refl _⟩
state_before: case intro.intro.cons
α : Type u_1
l₂ l l₁✝ l₂✝ : List α
a : α
s : l₁✝ <+ l₂✝
IH : l₁✝.length < l₂✝.length → ∃ a, a :: l₁✝ <+~ l₂✝
h : l₁✝.length < (a :: l₂✝).length
⊢ ∃ a_1, a_1 :: l₁✝ <+~ a :: l₂✝
state_after: no goals

tactic: exact (IH h).imp fun a s => s.trans (sublist_cons _ _).subperm
state_before: α : Type u_1
l₂ l l₁✝ l₂✝ : List α
a : α
s : l₁✝ <+ l₂✝
IH : l₁✝.length < l₂✝.length → ∃ a, a :: l₁✝ <+~ l₂✝
h✝ : l₁✝.length < (a :: l₂✝).length
h : l₁✝.length < l₂✝.length
⊢ ∃ a_1, a_1 :: l₁✝ <+~ a :: l₂✝
state_after: no goals

tactic: exact ⟨a, s.eq_of_length h ▸ .refl _⟩
state_before: α : Type u_1
l₂ l l₁✝ l₂✝ : List α
a : α
s : l₁✝ <+ l₂✝
IH : l₁✝.length < l₂✝.length → ∃ a, a :: l₁✝ <+~ l₂✝
h✝ : l₁✝.length < (a :: l₂✝).length
h : l₁✝.length = l₂✝.length
⊢ ∃ a_1, a_1 :: l₁✝ <+~ a :: l₂✝
state_after: no goals

tactic: exact (IH <| Nat.lt_of_succ_lt_succ h).imp fun a s =>
  (swap ..).subperm_right.1 <| (subperm_cons _).2 s
state_before: case intro.intro.cons₂
α : Type u_1
l₂ l l₁✝ l₂✝ : List α
b : α
a✝ : l₁✝ <+ l₂✝
IH : l₁✝.length < l₂✝.length → ∃ a, a :: l₁✝ <+~ l₂✝
h : (b :: l₁✝).length < (b :: l₂✝).length
⊢ ∃ a, a :: b :: l₁✝ <+~ b :: l₂✝
state_after: no goals
Theorem: Submonoid.map_powers
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝³ : Monoid M
a : M
N : Type u_4
F : Type u_5
inst✝² : Monoid N
inst✝¹ : FunLike F M N
inst✝ : MonoidHomClass F M N
f : F
m : M
⊢ map f (powers m) = powers (f m)
state_after: no goals
Theorem: zsmul_one
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: cases n <;> simp
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : AddGroupWithOne α
n : ℤ
⊢ n • 1 = ↑n
state_after: no goals
Theorem: MeasureTheory.Measure.rnDeriv_mul_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: refine (rnDeriv_withDensity_left ?_ ?_ ?_).symm.trans ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ μ.rnDeriv ν * ν.rnDeriv κ =ᶠ[ae κ] μ.rnDeriv κ
state_after: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ AEMeasurable (μ.rnDeriv ν) ν

case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ AEMeasurable (μ.rnDeriv ν) κ

case refine_3
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ ∀ᵐ (x : α) ∂ν, μ.rnDeriv ν x ≠ ⊤

case refine_4
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ (ν.withDensity (μ.rnDeriv ν)).rnDeriv κ =ᶠ[ae κ] μ.rnDeriv κ

tactic: exact (Measure.measurable_rnDeriv _ _).aemeasurable
state_before: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ AEMeasurable (μ.rnDeriv ν) ν
state_after: no goals

tactic: exact (Measure.measurable_rnDeriv _ _).aemeasurable
state_before: case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ AEMeasurable (μ.rnDeriv ν) κ
state_after: no goals

tactic: exact rnDeriv_ne_top _ _
state_before: case refine_3
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ ∀ᵐ (x : α) ∂ν, μ.rnDeriv ν x ≠ ⊤
state_after: no goals

tactic: rw [Measure.withDensity_rnDeriv_eq _ _ hμν]
state_before: case refine_4
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν κ : Measure α
inst✝² : SigmaFinite μ
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite κ
hμν : μ ≪ ν
⊢ (ν.withDensity (μ.rnDeriv ν)).rnDeriv κ =ᶠ[ae κ] μ.rnDeriv κ
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.hom_inv_whiskerRight'
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← comp_whiskerRight, IsIso.hom_inv_id, id_whiskerRight]
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝¹ : MonoidalCategory C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
Z : C
⊢ f ▷ Z ≫ inv f ▷ Z = 𝟙 (X ⊗ Z)
state_after: no goals
Theorem: CharTwo.neg_eq
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [neg_eq_iff_add_eq_zero, ← two_smul R x, two_eq_zero, zero_smul]
state_before: R : Type u_1
ι : Type u_2
inst✝¹ : Ring R
inst✝ : CharP R 2
x : R
⊢ -x = x
state_after: no goals
Theorem: CategoryTheory.Limits.prod.lift_fst_comp_snd_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [← prod.lift_map]
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ W X Y Z : C
inst✝¹ : HasBinaryProduct W Y
inst✝ : HasBinaryProduct X Z
g : W ⟶ X
g' : Y ⟶ Z
⊢ lift (fst ≫ g) (snd ≫ g') = map g g'
state_after: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ W X Y Z : C
inst✝¹ : HasBinaryProduct W Y
inst✝ : HasBinaryProduct X Z
g : W ⟶ X
g' : Y ⟶ Z
⊢ lift fst snd ≫ map g g' = map g g'

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ W X Y Z : C
inst✝¹ : HasBinaryProduct W Y
inst✝ : HasBinaryProduct X Z
g : W ⟶ X
g' : Y ⟶ Z
⊢ lift fst snd ≫ map g g' = map g g'
state_after: no goals
Theorem: Matroid.Restriction.eq_or_strictRestriction
File: Mathlib/Data/Matroid/Restrict.lean

tactic: simpa using eq_or_lt_of_le (ofMatroid_le_iff.2 h)
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
⊢ N = M ∨ N <r M
state_after: no goals
Theorem: SimpleGraph.cliqueFreeOn_empty
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp [CliqueFreeOn, Set.subset_empty_iff]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s s₁ s₂ : Set α
t : Finset α
a b : α
m n : ℕ
⊢ G.CliqueFreeOn ∅ n ↔ n ≠ 0
state_after: no goals
Theorem: ArithmeticFunction.cardDistinctFactors_apply_prime
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [← pow_one p, cardDistinctFactors_apply_prime_pow hp one_ne_zero]
state_before: R : Type u_1
p : ℕ
hp : Nat.Prime p
⊢ ω p = 1
state_after: no goals
Theorem: CategoryTheory.Pretriangulated.Triangle.eqToHom_hom₂
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

tactic: subst h
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
h : A = B
⊢ A.obj₂ = B.obj₂
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ A.obj₂ = A.obj₂

tactic: rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ A.obj₂ = A.obj₂
state_after: no goals

tactic: subst h
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
h : A = B
⊢ (eqToHom h).hom₂ = eqToHom ⋯
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ (eqToHom ⋯).hom₂ = eqToHom ⋯

tactic: rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ (eqToHom ⋯).hom₂ = eqToHom ⋯
state_after: no goals
Theorem: CategoryTheory.Limits.spanExt_app_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.left = iY
state_after: no goals
Theorem: Polynomial.roots_expand_map_frobenius_le
File: Mathlib/FieldTheory/Perfect.lean

tactic: rw [← iterateFrobenius_one]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
p n : ℕ
inst✝ : ExpChar R p
f : R[X]
⊢ Multiset.map (⇑(frobenius R p)) ((expand R p) f).roots ≤ p • f.roots
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
p n : ℕ
inst✝ : ExpChar R p
f : R[X]
⊢ Multiset.map (⇑(iterateFrobenius R p 1)) ((expand R p) f).roots ≤ p • f.roots

tactic: convert ← roots_expand_pow_map_iterateFrobenius_le p 1 f <;> apply pow_one
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
p n : ℕ
inst✝ : ExpChar R p
f : R[X]
⊢ Multiset.map (⇑(iterateFrobenius R p 1)) ((expand R p) f).roots ≤ p • f.roots
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.le_boundedBy'
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

tactic: rw [le_boundedBy, forall_congr']
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ μ ≤ boundedBy m ↔ ∀ (s : Set α), s.Nonempty → μ s ≤ m s
state_after: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), μ a ≤ m a ↔ a.Nonempty → μ a ≤ m a

tactic: intro s
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
⊢ ∀ (a : Set α), μ a ≤ m a ↔ a.Nonempty → μ a ≤ m a
state_after: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ m s ↔ s.Nonempty → μ s ≤ m s

tactic: rcases s.eq_empty_or_nonempty with h | h <;> simp [h]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ m s ↔ s.Nonempty → μ s ≤ m s
state_after: no goals
Theorem: Finset.mem_finsupp_iff_of_support_subset
File: Mathlib/Data/Finset/Finsupp.lean

tactic: refine
  mem_finsupp_iff.trans
    (forall_and.symm.trans <|
      forall_congr' fun i =>
        ⟨fun h => ?_, fun h =>
          ⟨fun hi => ht <| mem_support_iff.2 fun H => mem_support_iff.1 hi ?_, fun _ => h⟩⟩)
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
⊢ f ∈ s.finsupp ⇑t ↔ ∀ (i : ι), f i ∈ t i
state_after: case refine_1
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
⊢ f i ∈ t i

case refine_2
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : f i ∈ t i
hi : i ∈ f.support
H : t i = 0
⊢ f i = 0

tactic: by_cases hi : i ∈ s
state_before: case refine_1
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
⊢ f i ∈ t i
state_after: case pos
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
hi : i ∈ s
⊢ f i ∈ t i

case neg
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
hi : i ∉ s
⊢ f i ∈ t i

tactic: exact h.2 hi
state_before: case pos
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
hi : i ∈ s
⊢ f i ∈ t i
state_after: no goals

tactic: rw [not_mem_support_iff.1 (mt h.1 hi), not_mem_support_iff.1 fun H => hi <| ht H]
state_before: case neg
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
hi : i ∉ s
⊢ f i ∈ t i
state_after: case neg
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
hi : i ∉ s
⊢ 0 ∈ 0

tactic: exact zero_mem_zero
state_before: case neg
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
hi : i ∉ s
⊢ 0 ∈ 0
state_after: no goals

tactic: rwa [H, mem_zero] at h
state_before: case refine_2
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : ι →₀ α
t : ι →₀ Finset α
ht : t.support ⊆ s
i : ι
h : f i ∈ t i
hi : i ∈ f.support
H : t i = 0
⊢ f i = 0
state_after: no goals
Theorem: CircleDeg1Lift.commute_sub_nat
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [sub_eq_add_neg] using
  (f.commute_add_nat n).inverses_right (Equiv.addRight _).right_inv (Equiv.addRight _).left_inv
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ Function.Commute ⇑f fun x => x - ↑n
state_after: no goals
Theorem: Cardinal.toPartENat_natCast
File: Mathlib/SetTheory/Cardinal/PartENat.lean

tactic: simp only [← partENatOfENat_toENat, toENat_nat, PartENat.ofENat_coe]
state_before: α : Type u
n : ℕ
⊢ toPartENat ↑n = ↑n
state_after: no goals
Theorem: groupCohomology.shortComplexH0_exact
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

tactic: rw [ShortComplex.moduleCat_exact_iff]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ (shortComplexH0 A).Exact
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ∀ (x₂ : ↑(shortComplexH0 A).X₂), (shortComplexH0 A).g x₂ = 0 → ∃ x₁, (shortComplexH0 A).f x₁ = x₂

tactic: intro (x : A) (hx : dZero _ x = 0)
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ∀ (x₂ : ↑(shortComplexH0 A).X₂), (shortComplexH0 A).g x₂ = 0 → ∃ x₁, (shortComplexH0 A).f x₁ = x₂
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
⊢ ∃ x₁, (shortComplexH0 A).f x₁ = x

tactic: refine ⟨⟨x, fun g => ?_⟩, rfl⟩
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
⊢ ∃ x₁, (shortComplexH0 A).f x₁ = x
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x = x

tactic: rw [← sub_eq_zero]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x = x
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x - x = 0

tactic: exact congr_fun hx g
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x - x = 0
state_after: no goals
Theorem: MvPolynomial.NewtonIdentities.disjoint_filter_pairs_lt_filter_pairs_eq
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

tactic: rw [disjoint_filter]
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
⊢ Disjoint (filter (fun t => t.1.card < k) (MvPolynomial.NewtonIdentities.pairs σ k))
    (filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k))
state_after: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
⊢ ∀ x ∈ MvPolynomial.NewtonIdentities.pairs σ k, x.1.card < k → ¬x.1.card = k

tactic: exact fun _ _ h1 h2 ↦ lt_irrefl _ (h2.symm.subst h1)
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
⊢ ∀ x ∈ MvPolynomial.NewtonIdentities.pairs σ k, x.1.card < k → ¬x.1.card = k
state_after: no goals