1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.iterate_cancel
File: Mathlib/Logic/Function/Iterate.lean

tactic: obtain h | h := Nat.le_total m n
state_before: α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
⊢ f^[m - n] a = a
state_after: case inl
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : m ≤ n
⊢ f^[m - n] a = a

case inr
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : n ≤ m
⊢ f^[m - n] a = a

tactic: { simp [Nat.sub_eq_zero_of_le h] }
state_before: case inl
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : m ≤ n
⊢ f^[m - n] a = a

case inr
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : n ≤ m
⊢ f^[m - n] a = a
state_after: case inr
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : n ≤ m
⊢ f^[m - n] a = a

tactic: { exact iterate_cancel_of_add hf (by rwa [Nat.sub_add_cancel h]) }
state_before: case inr
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : n ≤ m
⊢ f^[m - n] a = a
state_after: no goals

tactic: simp [Nat.sub_eq_zero_of_le h]
state_before: case inl
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : m ≤ n
⊢ f^[m - n] a = a
state_after: no goals

tactic: exact iterate_cancel_of_add hf (by rwa [Nat.sub_add_cancel h])
state_before: case inr
α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : n ≤ m
⊢ f^[m - n] a = a
state_after: no goals

tactic: rwa [Nat.sub_add_cancel h]
state_before: α : Type u
β : Type v
f : α → α
m n : ℕ
a : α
hf : Injective f
ha : f^[m] a = f^[n] a
h : n ≤ m
⊢ f^[m - n + ?m.7867] a = f^[?m.7867] a
state_after: no goals
Theorem: MeasureTheory.Measure.sum_of_isEmpty
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← measure_univ_eq_zero, sum_apply _ MeasurableSet.univ, tsum_empty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
inst✝ : IsEmpty ι
μ : ι → Measure α
⊢ sum μ = 0
state_after: no goals
Theorem: Set.insert_diff_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: simp [insert_eq, union_diff_self, -union_singleton, -singleton_union]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
⊢ insert a (s \ {a}) = insert a s
state_after: no goals
Theorem: LinearOrderedField.lt_inducedMap_iff
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: rwa [coe_lt_inducedMap_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q✝ : ℚ
x✝ : ∃ q, b < ↑q ∧ ↑q < a
q : ℚ
hbq : b < ↑q
hqa : ↑q < a
⊢ ↑q < inducedMap α β a
state_after: no goals
Theorem: Equiv.Perm.list_cycles_perm_list_cycles
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: refine
  (List.perm_ext_iff_of_nodup (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
        (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
    fun σ => ?_
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
⊢ l₁ ~ l₂
state_after: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
⊢ σ ∈ l₁ ↔ σ ∈ l₂

tactic: by_cases hσ : σ.IsCycle
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
⊢ σ ∈ l₁ ↔ σ ∈ l₂
state_after: case pos
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : σ.IsCycle
⊢ σ ∈ l₁ ↔ σ ∈ l₂

case neg
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : ¬σ.IsCycle
⊢ σ ∈ l₁ ↔ σ ∈ l₂

tactic: obtain _ := not_forall.mp (mt ext hσ.ne_one)
state_before: case pos
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : σ.IsCycle
⊢ σ ∈ l₁ ↔ σ ∈ l₂
state_after: case pos
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : σ.IsCycle
x✝ : ∃ x, ¬σ x = 1 x
⊢ σ ∈ l₁ ↔ σ ∈ l₂

tactic: rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
state_before: case pos
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : σ.IsCycle
x✝ : ∃ x, ¬σ x = 1 x
⊢ σ ∈ l₁ ↔ σ ∈ l₂
state_after: no goals

tactic: exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
state_before: case neg
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : l₁.prod = l₂.prod
h₁l₁ : ∀ σ ∈ l₁, σ.IsCycle
h₁l₂ : ∀ σ ∈ l₂, σ.IsCycle
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : ¬σ.IsCycle
⊢ σ ∈ l₁ ↔ σ ∈ l₂
state_after: no goals
Theorem: Real.one_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← one_rpow z]
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ≤ x ^ z
state_after: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ^ z ≤ x ^ z

tactic: exact rpow_le_rpow zero_le_one hx hz
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ^ z ≤ x ^ z
state_after: no goals
Theorem: Real.negMulLog_zero
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

tactic: simp [negMulLog]
state_before: ⊢ negMulLog 0 = 0
state_after: no goals
Theorem: bernoulli'_spec'
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: refine ((sum_antidiagonal_eq_sum_range_succ_mk _ n).trans ?_).trans (bernoulli'_spec n)
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ antidiagonal n, ↑((k.1 + k.2).choose k.2) / (↑k.2 + 1) * bernoulli' k.1 = 1
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ range n.succ,
      ↑(((k, n - k).1 + (k, n - k).2).choose (k, n - k).2) / (↑(k, n - k).2 + 1) * bernoulli' (k, n - k).1 =
    ∑ k ∈ range n.succ, ↑(n.choose (n - k)) / (↑n - ↑k + 1) * bernoulli' k

tactic: refine sum_congr rfl fun x hx => ?_
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ range n.succ,
      ↑(((k, n - k).1 + (k, n - k).2).choose (k, n - k).2) / (↑(k, n - k).2 + 1) * bernoulli' (k, n - k).1 =
    ∑ k ∈ range n.succ, ↑(n.choose (n - k)) / (↑n - ↑k + 1) * bernoulli' k
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n x : ℕ
hx : x ∈ range n.succ
⊢ ↑(((x, n - x).1 + (x, n - x).2).choose (x, n - x).2) / (↑(x, n - x).2 + 1) * bernoulli' (x, n - x).1 =
    ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x

tactic: simp only [add_tsub_cancel_of_le, mem_range_succ_iff.mp hx, cast_sub]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n x : ℕ
hx : x ∈ range n.succ
⊢ ↑(((x, n - x).1 + (x, n - x).2).choose (x, n - x).2) / (↑(x, n - x).2 + 1) * bernoulli' (x, n - x).1 =
    ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x
state_after: no goals
Theorem: NonUnitalCommRing.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro rfl
state_before: R : Type u
inst₁ inst₂ : NonUnitalCommRing R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonUnitalCommRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul

tactic: constructor <;> rfl
state_before: R : Type u
inst₁ : NonUnitalCommRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
Theorem: RatFunc.ofFractionRing_eq
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: simp only [IsLocalization.algEquiv_apply, IsLocalization.ringEquivOfRingEquiv_apply,
  Localization.mk_eq_mk'_apply, IsLocalization.map_mk', ofFractionRing_mk',
  RingEquiv.coe_toRingHom, RingEquiv.refl_apply, SetLike.eta]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x✝ : FractionRing K[X]
x : K[X] × ↥K[X]⁰
⊢ { toFractionRing := Localization.mk x.1 x.2 } =
    (IsLocalization.algEquiv K[X]⁰ (FractionRing K[X]) (RatFunc K)) (Localization.mk x.1 x.2)
state_after: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x✝ : FractionRing K[X]
x : K[X] × ↥K[X]⁰
⊢ IsLocalization.mk' (RatFunc K) x.1 x.2 =
    IsLocalization.mk' (RatFunc K) ((RingHom.id K[X]) x.1) ⟨(RingHom.id K[X]) ↑x.2, ⋯⟩

tactic: simp only [IsFractionRing.mk'_eq_div, RingHom.id_apply, Subtype.coe_eta]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x✝ : FractionRing K[X]
x : K[X] × ↥K[X]⁰
⊢ IsLocalization.mk' (RatFunc K) x.1 x.2 =
    IsLocalization.mk' (RatFunc K) ((RingHom.id K[X]) x.1) ⟨(RingHom.id K[X]) ↑x.2, ⋯⟩
state_after: no goals
Theorem: Ordinal.principal_add_isLimit
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine ⟨fun ho₀ => ?_, fun a hao => ?_⟩
state_before: o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
⊢ o.IsLimit
state_after: case refine_1
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False

case refine_2
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
⊢ succ a < o

tactic: rw [ho₀] at ho₁
state_before: case refine_1
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False
state_after: case refine_1
o : Ordinal.{u_1}
ho₁ : 1 < 0
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False

tactic: exact not_lt_of_gt zero_lt_one ho₁
state_before: case refine_1
o : Ordinal.{u_1}
ho₁ : 1 < 0
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False
state_after: no goals

tactic: rcases eq_or_ne a 0 with ha | ha
state_before: case refine_2
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
⊢ succ a < o
state_after: case refine_2.inl
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a = 0
⊢ succ a < o

case refine_2.inr
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a ≠ 0
⊢ succ a < o

tactic: rw [ha, succ_zero]
state_before: case refine_2.inl
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a = 0
⊢ succ a < o
state_after: case refine_2.inl
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a = 0
⊢ 1 < o

tactic: exact ho₁
state_before: case refine_2.inl
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a = 0
⊢ 1 < o
state_after: no goals

tactic: refine lt_of_le_of_lt ?_ (ho hao hao)
state_before: case refine_2.inr
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a ≠ 0
⊢ succ a < o
state_after: case refine_2.inr
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a ≠ 0
⊢ succ a ≤ (fun x x_1 => x + x_1) a a

tactic: rwa [← add_one_eq_succ, add_le_add_iff_left, one_le_iff_ne_zero]
state_before: case refine_2.inr
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
ha : a ≠ 0
⊢ succ a ≤ (fun x x_1 => x + x_1) a a
state_after: no goals
Theorem: Filter.subtype_coe_map_comap
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [map_comap, Subtype.range_coe]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
f : Filter α
⊢ map Subtype.val (comap Subtype.val f) = f ⊓ 𝓟 s
state_after: no goals
Theorem: Multiset.add_eq_union_right_of_le
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa only [and_comm] using add_eq_union_left_of_le h
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
x y z : Multiset α
h : z ≤ y
⊢ x + y = x ∪ z ↔ y = z ∧ x.Disjoint y
state_after: no goals
Theorem: Metric.hausdorffDist_closure₁
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [hausdorffDist]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ hausdorffDist (closure s) t = hausdorffDist s t
state_after: no goals
Theorem: PowerSeries.span_X_isPrime
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: suffices Ideal.span ({X} : Set R⟦X⟧) = RingHom.ker (constantCoeff R) by
  rw [this]
  exact RingHom.ker_isPrime _
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ (Ideal.span {X}).IsPrime
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ Ideal.span {X} = RingHom.ker (constantCoeff R)

tactic: apply Ideal.ext
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ Ideal.span {X} = RingHom.ker (constantCoeff R)
state_after: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ ∀ (x : R⟦X⟧), x ∈ Ideal.span {X} ↔ x ∈ RingHom.ker (constantCoeff R)

tactic: intro φ
state_before: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ ∀ (x : R⟦X⟧), x ∈ Ideal.span {X} ↔ x ∈ RingHom.ker (constantCoeff R)
state_after: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
φ : R⟦X⟧
⊢ φ ∈ Ideal.span {X} ↔ φ ∈ RingHom.ker (constantCoeff R)

tactic: rw [RingHom.mem_ker, Ideal.mem_span_singleton, X_dvd_iff]
state_before: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
φ : R⟦X⟧
⊢ φ ∈ Ideal.span {X} ↔ φ ∈ RingHom.ker (constantCoeff R)
state_after: no goals

tactic: rw [this]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
this : Ideal.span {X} = RingHom.ker (constantCoeff R)
⊢ (Ideal.span {X}).IsPrime
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
this : Ideal.span {X} = RingHom.ker (constantCoeff R)
⊢ (RingHom.ker (constantCoeff R)).IsPrime

tactic: exact RingHom.ker_isPrime _
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
this : Ideal.span {X} = RingHom.ker (constantCoeff R)
⊢ (RingHom.ker (constantCoeff R)).IsPrime
state_after: no goals
Theorem: LaurentPolynomial.induction_on_mul_T
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: rcases f.exists_T_pow with ⟨n, f', hf⟩
state_before: R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (toLaurent f * T (-↑n))
⊢ Q f
state_after: case intro.intro
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (toLaurent f * T (-↑n))
n : ℕ
f' : R[X]
hf : toLaurent f' = f * T ↑n
⊢ Q f

tactic: rw [← mul_one f, ← T_zero, ← Nat.cast_zero, ← Nat.sub_self n, Nat.cast_sub rfl.le, T_sub,
  ← mul_assoc, ← hf]
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (toLaurent f * T (-↑n))
n : ℕ
f' : R[X]
hf : toLaurent f' = f * T ↑n
⊢ Q f
state_after: case intro.intro
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (toLaurent f * T (-↑n))
n : ℕ
f' : R[X]
hf : toLaurent f' = f * T ↑n
⊢ Q (toLaurent f' * T (-↑n))

tactic: exact Qf
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (toLaurent f * T (-↑n))
n : ℕ
f' : R[X]
hf : toLaurent f' = f * T ↑n
⊢ Q (toLaurent f' * T (-↑n))
state_after: no goals
Theorem: ContMDiffOn.div₀
File: Mathlib/Geometry/Manifold/Algebra/LieGroup.lean

tactic: simpa [div_eq_mul_inv] using hf.mul (hg.inv₀ h₀)
state_before: 𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
H : Type u_2
inst✝¹² : TopologicalSpace H
E : Type u_3
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
I : ModelWithCorners 𝕜 E H
G : Type u_4
inst✝⁹ : TopologicalSpace G
inst✝⁸ : ChartedSpace H G
inst✝⁷ : GroupWithZero G
inst✝⁶ : SmoothInv₀ I G
inst✝⁵ : SmoothMul I G
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_7
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H' M
f g : M → G
s : Set M
a : M
n : ℕ∞
hf : ContMDiffOn I' I n f s
hg : ContMDiffOn I' I n g s
h₀ : ∀ x ∈ s, g x ≠ 0
⊢ ContMDiffOn I' I n (f / g) s
state_after: no goals
Theorem: RootPairing.choose_choose_eq_of_mapsTo
File: Mathlib/LinearAlgebra/RootSystem/Basic.lean

tactic: refine root.injective ?_
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
root : ι ↪ M
coroot : ι ↪ N
i j : ι
h : ∀ (i : ι), MapsTo (⇑(preReflection (root i) (p.toLin.flip (coroot i)))) (range ⇑root) (range ⇑root)
hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2
⊢ ⋯.choose = j
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
root : ι ↪ M
coroot : ι ↪ N
i j : ι
h : ∀ (i : ι), MapsTo (⇑(preReflection (root i) (p.toLin.flip (coroot i)))) (range ⇑root) (range ⇑root)
hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2
⊢ root ⋯.choose = root j

tactic: rw [(exist_eq_reflection_of_mapsTo p root coroot i _ h).choose_spec,
  (exist_eq_reflection_of_mapsTo p root coroot i j h).choose_spec]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
root : ι ↪ M
coroot : ι ↪ N
i j : ι
h : ∀ (i : ι), MapsTo (⇑(preReflection (root i) (p.toLin.flip (coroot i)))) (range ⇑root) (range ⇑root)
hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2
⊢ root ⋯.choose = root j
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
root : ι ↪ M
coroot : ι ↪ N
i j : ι
h : ∀ (i : ι), MapsTo (⇑(preReflection (root i) (p.toLin.flip (coroot i)))) (range ⇑root) (range ⇑root)
hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2
⊢ (preReflection (root i) (p.toLin.flip (coroot i))) ((preReflection (root i) (p.toLin.flip (coroot i))) (root j)) =
    root j

tactic: apply involutive_preReflection (x := root i) (hp i)
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
root : ι ↪ M
coroot : ι ↪ N
i j : ι
h : ∀ (i : ι), MapsTo (⇑(preReflection (root i) (p.toLin.flip (coroot i)))) (range ⇑root) (range ⇑root)
hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2
⊢ (preReflection (root i) (p.toLin.flip (coroot i))) ((preReflection (root i) (p.toLin.flip (coroot i))) (root j)) =
    root j
state_after: no goals
Theorem: norm_le_mul_norm_add
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mul_div_cancel_right]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖u‖ = ‖u * v / v‖
state_after: no goals
Theorem: Semiring.toNonAssocSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

tactic: intro _ _ h
state_before: R : Type u
⊢ Function.Injective (@toNonAssocSemiring R)
state_after: R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonAssocSemiring = toNonAssocSemiring
⊢ a₁✝ = a₂✝

tactic: ext x y
state_before: R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonAssocSemiring = toNonAssocSemiring
⊢ a₁✝ = a₂✝
state_after: case h_add.h.h
R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonAssocSemiring = toNonAssocSemiring
x y : R
⊢ x + y = x + y

case h_mul.h.h
R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonAssocSemiring = toNonAssocSemiring
x y : R
⊢ x * y = x * y
Theorem: UniformSpace.toTopologicalSpace_sInf
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp only [← toTopologicalSpace_iInf]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s : Set (UniformSpace α)
⊢ toTopologicalSpace = ⨅ i ∈ s, toTopologicalSpace
state_after: no goals
Theorem: CategoryTheory.Sheaf.Hom.mono_iff_presheaf_mono
File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

tactic: infer_instance
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
F G : Sheaf J D
f : F ⟶ G
m : Mono f
⊢ Mono f.val
state_after: no goals

tactic: exact Sheaf.Hom.mono_of_presheaf_mono J D f
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
F G : Sheaf J D
f : F ⟶ G
m : Mono f.val
⊢ Mono f
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.δ_L₃_f
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: erw [← cancel_epi S.L₀'.g, S.L₀'_exact.g_desc_assoc, assoc, S.v₂₃.comm₁₂, S.φ₁_L₂_f_assoc,
  φ₂, assoc, w₁₃_τ₂, comp_zero, comp_zero]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.δ ≫ S.L₃.f = 0
state_after: no goals