1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.log_div
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [exp_log_eq_abs (div_ne_zero hx hy), exp_sub, exp_log_eq_abs hx, exp_log_eq_abs hy, abs_div]
state_before: x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ rexp (log (x / y)) = rexp (log x - log y)
state_after: no goals
Theorem: Finset.fold_image
File: Mathlib/Data/Finset/Fold.lean

tactic: simp only [fold, image_val_of_injOn H, Multiset.map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s✝ : Finset α
a : α
inst✝ : DecidableEq α
g : γ → α
s : Finset γ
H : ∀ x ∈ s, ∀ y ∈ s, g x = g y → x = y
⊢ fold op b f (image g s) = fold op b (f ∘ g) s
state_after: no goals
Theorem: Multiset.fold_add
File: Mathlib/Data/Multiset/Fold.lean

tactic: rw [add_zero, fold_zero, ← fold_cons'_right, ← fold_cons_right op]
state_before: α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
b₁ b₂ : α
s₁ s₂ : Multiset α
⊢ fold op (op b₁ b₂) (s₁ + 0) = op (fold op b₁ s₁) (fold op b₂ 0)
state_after: no goals

tactic: rw [fold_cons_left, add_cons, fold_cons_left, h, ← ha.assoc, hc.comm a,
ha.assoc]
state_before: α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
b₁ b₂ : α
s₁ s₂ : Multiset α
a : α
b : Multiset α
h : fold op (op b₁ b₂) (s₁ + b) = op (fold op b₁ s₁) (fold op b₂ b)
⊢ fold op (op b₁ b₂) (s₁ + a ::ₘ b) = op (fold op b₁ s₁) (fold op b₂ (a ::ₘ b))
state_after: no goals
Theorem: CategoryTheory.MonoOver.factors_congr
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: simp [hu]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : C
f g : MonoOver X
Y : C
h : Y ⟶ X
e : f ≅ g
x✝ : f.Factors h
u : Y ⟶ f.obj.left
hu : u ≫ f.arrow = h
⊢ (u ≫ ((forget X).map e.hom).left) ≫ g.arrow = h
state_after: no goals

tactic: simp [hu]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : C
f g : MonoOver X
Y : C
h : Y ⟶ X
e : f ≅ g
x✝ : g.Factors h
u : Y ⟶ g.obj.left
hu : u ≫ g.arrow = h
⊢ (u ≫ ((forget X).map e.inv).left) ≫ f.arrow = h
state_after: no goals
Theorem: Finset.mul_noncommProd_erase
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: classical
simpa only [← Multiset.map_erase_of_mem _ _ h] using
  Multiset.mul_noncommProd_erase (s.1.map f) (Multiset.mem_map_of_mem f h) _
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid β
inst✝² : Monoid γ
inst✝¹ : FunLike F β γ
inst✝ : DecidableEq α
s : Finset α
a : α
h : a ∈ s
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
comm' : optParam (∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y) ⋯
⊢ f a * (s.erase a).noncommProd f comm' = s.noncommProd f comm
state_after: no goals

tactic: simpa only [← Multiset.map_erase_of_mem _ _ h] using
  Multiset.mul_noncommProd_erase (s.1.map f) (Multiset.mem_map_of_mem f h) _
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid β
inst✝² : Monoid γ
inst✝¹ : FunLike F β γ
inst✝ : DecidableEq α
s : Finset α
a : α
h : a ∈ s
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
comm' : optParam (∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y) ⋯
⊢ f a * (s.erase a).noncommProd f comm' = s.noncommProd f comm
state_after: no goals
Theorem: Real.sin_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sub_eq_add_neg, sin_add]
state_before: x : ℝ
⊢ sin (π / 2 - x) = cos x
state_after: no goals
Theorem: CategoryTheory.StrongMono.of_arrow_iso
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

tactic: rw [Arrow.iso_w' e]
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
⊢ Mono g
state_after: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)

tactic: haveI := mono_comp f e.hom.right
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)
state_after: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
this : Mono (f ≫ e.hom.right)
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)

tactic: apply mono_comp
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
this : Mono (f ≫ e.hom.right)
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)
state_after: no goals

tactic: intro
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
X Y : C
z : X ⟶ Y
⊢ ∀ [inst : Epi z], HasLiftingProperty z g
state_after: C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
X Y : C
z : X ⟶ Y
inst✝ : Epi z
⊢ HasLiftingProperty z g

tactic: apply HasLiftingProperty.of_arrow_iso_right z e
state_before: C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
X Y : C
z : X ⟶ Y
inst✝ : Epi z
⊢ HasLiftingProperty z g
state_after: no goals
Theorem: RingHom.map_geom_sum₂
File: Mathlib/Algebra/GeomSum.lean

tactic: simp [map_sum f]
state_before: α : Type u
β : Type u_1
inst✝¹ : Semiring α
inst✝ : Semiring β
x y : α
n : ℕ
f : α →+* β
⊢ f (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) = ∑ i ∈ range n, f x ^ i * f y ^ (n - 1 - i)
state_after: no goals
Theorem: Ordinal.IsFundamentalSequence.cof_eq
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← hf.2.2]
state_before: α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : a.IsFundamentalSequence o f
⊢ a.cof.ord ≤ o
state_after: α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : a.IsFundamentalSequence o f
⊢ (o.blsub f).cof.ord ≤ o

tactic: exact (ord_le_ord.2 (cof_blsub_le f)).trans (ord_card_le o)
state_before: α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : a.IsFundamentalSequence o f
⊢ (o.blsub f).cof.ord ≤ o
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Hom.invApp_app
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

tactic: exact Set.preimage_image_eq U.1 H.base_open.inj
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Opens ↑↑X.toPresheafedSpace
⊢ ↑(f ⁻¹ᵁ f ''ᵁ U) = ↑U
state_after: no goals

tactic: rw [eqToHom_op]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Opens ↑↑X.toPresheafedSpace
⊢ X.presheaf.map (eqToHom ⋯) = X.presheaf.map (eqToHom ⋯).op
state_after: no goals
Theorem: RatFunc.numDenom_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rw [numDenom, liftOn'_div, if_neg hq]
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).numDenom =
    (C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q), C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q))
state_after: case f0
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ∀ (p : K[X]),
    (if 0 = 0 then (0, 1)
      else
        let r := gcd p 0;
        (C (0 / r).leadingCoeff⁻¹ * (p / r), C (0 / r).leadingCoeff⁻¹ * (0 / r))) =
      if 1 = 0 then (0, 1)
      else
        let r := gcd 0 1;
        (C (1 / r).leadingCoeff⁻¹ * (0 / r), C (1 / r).leadingCoeff⁻¹ * (1 / r))

tactic: intro p
state_before: case f0
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ∀ (p : K[X]),
    (if 0 = 0 then (0, 1)
      else
        let r := gcd p 0;
        (C (0 / r).leadingCoeff⁻¹ * (p / r), C (0 / r).leadingCoeff⁻¹ * (0 / r))) =
      if 1 = 0 then (0, 1)
      else
        let r := gcd 0 1;
        (C (1 / r).leadingCoeff⁻¹ * (0 / r), C (1 / r).leadingCoeff⁻¹ * (1 / r))
state_after: case f0
K : Type u
inst✝ : Field K
p✝ q : K[X]
hq : q ≠ 0
p : K[X]
⊢ (if 0 = 0 then (0, 1)
    else
      let r := gcd p 0;
      (C (0 / r).leadingCoeff⁻¹ * (p / r), C (0 / r).leadingCoeff⁻¹ * (0 / r))) =
    if 1 = 0 then (0, 1)
    else
      let r := gcd 0 1;
      (C (1 / r).leadingCoeff⁻¹ * (0 / r), C (1 / r).leadingCoeff⁻¹ * (1 / r))

tactic: rw [if_pos rfl, if_neg (one_ne_zero' K[X])]
state_before: case f0
K : Type u
inst✝ : Field K
p✝ q : K[X]
hq : q ≠ 0
p : K[X]
⊢ (if 0 = 0 then (0, 1)
    else
      let r := gcd p 0;
      (C (0 / r).leadingCoeff⁻¹ * (p / r), C (0 / r).leadingCoeff⁻¹ * (0 / r))) =
    if 1 = 0 then (0, 1)
    else
      let r := gcd 0 1;
      (C (1 / r).leadingCoeff⁻¹ * (0 / r), C (1 / r).leadingCoeff⁻¹ * (1 / r))
state_after: case f0
K : Type u
inst✝ : Field K
p✝ q : K[X]
hq : q ≠ 0
p : K[X]
⊢ (0, 1) =
    let r := gcd 0 1;
    (C (1 / r).leadingCoeff⁻¹ * (0 / r), C (1 / r).leadingCoeff⁻¹ * (1 / r))

tactic: simp
state_before: case f0
K : Type u
inst✝ : Field K
p✝ q : K[X]
hq : q ≠ 0
p : K[X]
⊢ (0, 1) =
    let r := gcd 0 1;
    (C (1 / r).leadingCoeff⁻¹ * (0 / r), C (1 / r).leadingCoeff⁻¹ * (1 / r))
state_after: no goals
Theorem: IsBoundedLinearMap.id
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: simp [le_refl]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
⊢ ∀ (x : E), ‖LinearMap.id x‖ ≤ 1 * ‖x‖
state_after: no goals
Theorem: AList.insert_insert
File: Mathlib/Data/List/AList.lean

tactic: ext : 1
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
s : AList β
⊢ insert a b' (insert a b s) = insert a b' s
state_after: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
s : AList β
⊢ (insert a b' (insert a b s)).entries = (insert a b' s).entries

tactic: simp only [AList.insert_entries, List.kerase_cons_eq]
state_before: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
s : AList β
⊢ (insert a b' (insert a b s)).entries = (insert a b' s).entries
state_after: no goals
Theorem: LieAlgebra.IsKilling.chainLength_zero
File: Mathlib/Algebra/Lie/Weights/RootSystem.lean

tactic: simp [← chainBotCoeff_add_chainTopCoeff]
state_before: K : Type u_1
L : Type u_2
inst✝⁸ : Field K
inst✝⁷ : CharZero K
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra K L
inst✝⁴ : IsKilling K L
inst✝³ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝² : H.IsCartanSubalgebra
inst✝¹ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
inst✝ : Nontrivial L
⊢ chainLength 0 β = 0
state_after: no goals
Theorem: Matroid.uniqueBaseOn_indep_iff'
File: Mathlib/Data/Matroid/Constructions.lean

tactic: rw [uniqueBaseOn, restrict_indep_iff, freeOn_indep_iff, subset_inter_iff]
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ (uniqueBaseOn I E).Indep J ↔ J ⊆ I ∩ E
state_after: no goals
Theorem: ProbabilityTheory.geometricPMFReal_pos
File: Mathlib/Probability/Distributions/Geometric.lean

tactic: rw [geometricPMFReal]
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
⊢ 0 < geometricPMFReal p n
state_after: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
⊢ 0 < (1 - p) ^ n * p

tactic: have : 0 < 1 - p := sub_pos.mpr hp_lt_one
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
⊢ 0 < (1 - p) ^ n * p
state_after: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
this : 0 < 1 - p
⊢ 0 < (1 - p) ^ n * p

tactic: positivity
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
this : 0 < 1 - p
⊢ 0 < (1 - p) ^ n * p
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.associator_conjugation
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [associator_inv_naturality, hom_inv_id_assoc]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X X' Y Y' Z Z' : C
f : X ⟶ X'
g : Y ⟶ Y'
h : Z ⟶ Z'
⊢ (f ⊗ g) ⊗ h = (α_ X Y Z).hom ≫ (f ⊗ g ⊗ h) ≫ (α_ X' Y' Z').inv
state_after: no goals
Theorem: List.norm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a : α
x✝ : [a] ≠ []
⊢ ‖[a].prod‖ ≤ (map norm [a]).prod
state_after: no goals

tactic: rw [List.map_cons, List.prod_cons, @List.prod_cons _ _ _ ‖a‖]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a b : α
l : List α
x✝ : a :: b :: l ≠ []
⊢ ‖(a :: b :: l).prod‖ ≤ (map norm (a :: b :: l)).prod
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a b : α
l : List α
x✝ : a :: b :: l ≠ []
⊢ ‖a * (b :: l).prod‖ ≤ ‖a‖ * (map norm (b :: l)).prod

tactic: refine le_trans (norm_mul_le _ _) (mul_le_mul_of_nonneg_left ?_ (norm_nonneg _))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a b : α
l : List α
x✝ : a :: b :: l ≠ []
⊢ ‖a * (b :: l).prod‖ ≤ ‖a‖ * (map norm (b :: l)).prod
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a b : α
l : List α
x✝ : a :: b :: l ≠ []
⊢ ‖(b :: l).prod‖ ≤ (map norm (b :: l)).prod

tactic: exact List.norm_prod_le' (List.cons_ne_nil b l)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a b : α
l : List α
x✝ : a :: b :: l ≠ []
⊢ ‖(b :: l).prod‖ ≤ (map norm (b :: l)).prod
state_after: no goals
Theorem: boole_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : MulZeroOneClass α
P : Prop
inst✝ : Decidable P
a : α
⊢ (if P then 1 else 0) * a = if P then a else 0
state_after: no goals
Theorem: Equiv.Perm.zpow_apply_eq_of_apply_apply_eq_self
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [zpow_negSucc, inv_eq_iff_eq, ← f.injective.eq_iff, ← mul_apply, ← pow_succ', eq_comm,
  inv_eq_iff_eq, ← mul_apply, ← pow_succ, @eq_comm _ x, or_comm]
state_before: α : Type u_1
f g h : Perm α
x : α
hffx : f (f x) = x
n : ℕ
⊢ (f ^ Int.negSucc n) x = x ∨ (f ^ Int.negSucc n) x = f x
state_after: α : Type u_1
f g h : Perm α
x : α
hffx : f (f x) = x
n : ℕ
⊢ (f ^ (n + 1 + 1)) x = x ∨ (f ^ (n + 1 + 1)) x = f x

tactic: exact pow_apply_eq_of_apply_apply_eq_self hffx _
state_before: α : Type u_1
f g h : Perm α
x : α
hffx : f (f x) = x
n : ℕ
⊢ (f ^ (n + 1 + 1)) x = x ∨ (f ^ (n + 1 + 1)) x = f x
state_after: no goals
Theorem: PerfectClosure.R.sound
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: subst H
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m n : ℕ
x y : K
H : (⇑(frobenius K p))^[m] x = y
⊢ mk K p (n, x) = mk K p (m + n, y)
state_after: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)

tactic: induction' m with m ih
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
state_after: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (0 + n, (⇑(frobenius K p))^[0] x)

case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (n, x) = mk K p (m + 1 + n, (⇑(frobenius K p))^[m + 1] x)

tactic: rw [ih, Nat.succ_add, iterate_succ']
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (n, x) = mk K p (m + 1 + n, (⇑(frobenius K p))^[m + 1] x)
state_after: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (m + n, (⇑(frobenius K p))^[m] x) = mk K p ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)

tactic: apply Quot.sound
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ mk K p (m + n, (⇑(frobenius K p))^[m] x) = mk K p ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)
state_after: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ R K p (m + n, (⇑(frobenius K p))^[m] x) ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)

tactic: apply R.intro
state_before: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
m : ℕ
ih : mk K p (n, x) = mk K p (m + n, (⇑(frobenius K p))^[m] x)
⊢ R K p (m + n, (⇑(frobenius K p))^[m] x) ((m + n).succ, (⇑(frobenius K p) ∘ (⇑(frobenius K p))^[m]) x)
state_after: no goals

tactic: simp only [Nat.zero_eq, zero_add, iterate_zero_apply]
state_before: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
⊢ mk K p (n, x) = mk K p (0 + n, (⇑(frobenius K p))^[0] x)
state_after: no goals
Theorem: StructureGroupoid.LocalInvariantProp.liftPropWithinAt_of_liftPropAt_of_mem_nhds
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rwa [← univ_inter s, hG.liftPropWithinAt_inter hs]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type u_5
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : PartialHomeomorph M H
f f' : PartialHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : G.LocalInvariantProp G' P
h : LiftPropAt P g x
hs : s ∈ 𝓝 x
⊢ LiftPropWithinAt P g s x
state_after: no goals
Theorem: Polynomial.taylor_one
File: Mathlib/Algebra/Polynomial/Taylor.lean

tactic: rw [← C_1, taylor_C]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ (taylor r) 1 = C 1
state_after: no goals
Theorem: one_div_mul_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ 1 / a * b = b / a
state_after: no goals
Theorem: Set.ordConnected_iff_uIcc_subset_right
File: Mathlib/Order/Interval/Set/OrdConnected.lean

tactic: simp_rw [ordConnected_iff_uIcc_subset_left hx, uIcc_comm]
state_before: α : Type u_1
inst✝ : LinearOrder α
s : Set α
x : α
hx : x ∈ s
⊢ s.OrdConnected ↔ ∀ ⦃y : α⦄, y ∈ s → [[y, x]] ⊆ s
state_after: no goals
Theorem: List.foldr_eta
File: Mathlib/Data/List/Basic.lean

tactic: simp only [foldr_self_append, append_nil, forall_const]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
⊢ ∀ (l : List α), foldr cons [] l = l
state_after: no goals
Theorem: Polynomial.cyclotomic_mul_prime_dvd_eq_pow
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Expand.lean

tactic: letI : Algebra (ZMod p) R := ZMod.algebra _ _
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p
state_after: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p

tactic: suffices cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p by
  rw [← map_cyclotomic _ (algebraMap (ZMod p) R), ← map_cyclotomic _ (algebraMap (ZMod p) R),
    this, Polynomial.map_pow]
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p
state_after: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p

tactic: rw [← ZMod.expand_card, ← map_cyclotomic_int n, ← map_expand,
  cyclotomic_expand_eq_cyclotomic hp.out hn, map_cyclotomic]
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p
state_after: no goals

tactic: rw [← map_cyclotomic _ (algebraMap (ZMod p) R), ← map_cyclotomic _ (algebraMap (ZMod p) R),
  this, Polynomial.map_pow]
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this✝ : Algebra (ZMod p) R := ZMod.algebra R p
this : cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p
state_after: no goals
Theorem: Vector.mapAccumr₂_mapAccumr₂_right_right
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
γ σ₁ φ σ₂ : Type
s₂ : σ₂
s₁ : σ₁
f₁ : β → γ → σ₁ → σ₁ × φ
f₂ : α → β → σ₂ → σ₂ × γ
⊢ mapAccumr₂ f₁ ys (mapAccumr₂ f₂ xs ys s₂).2 s₁ =
    let m :=
      mapAccumr₂
        (fun x y x_1 =>
          match x_1 with
          | (s₁, s₂) =>
            let r₂ := f₂ x y s₂;
            let r₁ := f₁ y r₂.2 s₁;
            ((r₁.1, r₂.1), r₁.2))
        xs ys (s₁, s₂);
    (m.1.1, m.2)
state_after: no goals
Theorem: thickenedIndicator_le_one
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: rw [thickenedIndicator.coeFn_eq_comp]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
⊢ (thickenedIndicator δ_pos E) x ≤ 1
state_after: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
⊢ (ENNReal.toNNReal ∘ thickenedIndicatorAux δ E) x ≤ 1

tactic: simpa using (toNNReal_le_toNNReal thickenedIndicatorAux_lt_top.ne one_ne_top).mpr
  (thickenedIndicatorAux_le_one δ E x)
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
⊢ (ENNReal.toNNReal ∘ thickenedIndicatorAux δ E) x ≤ 1
state_after: no goals
Theorem: Set.eq_of_inclusion_surjective
File: Mathlib/Data/Set/Basic.lean

tactic: refine Set.Subset.antisymm h (fun x hx => ?_)
state_before: α : Type u_1
s✝ t✝ u s t : Set α
h : s ⊆ t
h_surj : Surjective (inclusion h)
⊢ s = t
state_after: α : Type u_1
s✝ t✝ u s t : Set α
h : s ⊆ t
h_surj : Surjective (inclusion h)
x : α
hx : x ∈ t
⊢ x ∈ s

tactic: obtain ⟨y, hy⟩ := h_surj ⟨x, hx⟩
state_before: α : Type u_1
s✝ t✝ u s t : Set α
h : s ⊆ t
h_surj : Surjective (inclusion h)
x : α
hx : x ∈ t
⊢ x ∈ s
state_after: case intro
α : Type u_1
s✝ t✝ u s t : Set α
h : s ⊆ t
h_surj : Surjective (inclusion h)
x : α
hx : x ∈ t
y : ↑s
hy : inclusion h y = ⟨x, hx⟩
⊢ x ∈ s

tactic: exact mem_of_eq_of_mem (congr_arg Subtype.val hy).symm y.prop
state_before: case intro
α : Type u_1
s✝ t✝ u s t : Set α
h : s ⊆ t
h_surj : Surjective (inclusion h)
x : α
hx : x ∈ t
y : ↑s
hy : inclusion h y = ⟨x, hx⟩
⊢ x ∈ s
state_after: no goals