1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: PadicSeq.norm_values_discrete
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: let ⟨k, hk, hk'⟩ := norm_eq_norm_app_of_nonzero ha
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : PadicSeq p
ha : ¬a ≈ 0
⊢ ∃ z, a.norm = ↑p ^ (-z)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
a : PadicSeq p
ha : ¬a ≈ 0
k : ℚ
hk : a.norm = padicNorm p k
hk' : k ≠ 0
⊢ ∃ z, a.norm = ↑p ^ (-z)

tactic: simpa [hk] using padicNorm.values_discrete hk'
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : PadicSeq p
ha : ¬a ≈ 0
k : ℚ
hk : a.norm = padicNorm p k
hk' : k ≠ 0
⊢ ∃ z, a.norm = ↑p ^ (-z)
state_after: no goals
Theorem: Function.Surjective.preimage_subset_preimage_iff
File: Mathlib/Data/Set/Image.lean

tactic: apply Set.preimage_subset_preimage_iff
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ f ⁻¹' s ⊆ f ⁻¹' t ↔ s ⊆ t
state_after: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ range f

tactic: rw [hf.range_eq]
state_before: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ range f
state_after: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ univ

tactic: apply subset_univ
state_before: case hs
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
s t : Set β
hf : Surjective f
⊢ s ⊆ univ
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.unop_left_comp_ofMkLEMk_unop
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: conv_lhs =>
  congr
  rw [← Quiver.Hom.unop_op g.unop.left]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ { unop := A }
g : Q ⟶ { unop := A }
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ { unop := A }
g : Q ⟶ { unop := A }
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left.op.unop ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left

tactic: rw [← unop_comp]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ { unop := A }
g : Q ⟶ { unop := A }
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left.op.unop ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ { unop := A }
g : Q ⟶ { unop := A }
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h ≫ g.unop.left.op).unop = f.unop.left

tactic: simp only [Subobject.ofMkLEMk_comp, Quiver.Hom.unop_op]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ { unop := A }
g : Q ⟶ { unop := A }
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h ≫ g.unop.left.op).unop = f.unop.left
state_after: no goals
Theorem: Sym2.toRel_symmetric
File: Mathlib/Data/Sym/Sym2.lean

tactic: simp [eq_swap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
r : α → α → Prop
s : Set (Sym2 α)
x y : α
⊢ ToRel s x y → ToRel s y x
state_after: no goals
Theorem: Ordinal.le_bmex_of_forall
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: by_contra! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
a : Ordinal.{max u_4 u_5}
H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b
⊢ a ≤ o.bmex f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
a : Ordinal.{max u_4 u_5}
H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b
h : o.bmex f < a
⊢ False

tactic: exact bmex_not_mem_brange f (H _ h)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
a : Ordinal.{max u_4 u_5}
H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b
h : o.bmex f < a
⊢ False
state_after: no goals
Theorem: commProb_prod
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: simp_rw [commProb_def, div_mul_div_comm, Nat.card_prod, Nat.cast_mul, mul_pow, ← Nat.cast_mul,
  ← Nat.card_prod, Commute, SemiconjBy, Prod.ext_iff]
state_before: M : Type u_1
inst✝¹ : Mul M
M' : Type u_2
inst✝ : Mul M'
⊢ commProb (M × M') = commProb M * commProb M'
state_after: M : Type u_1
inst✝¹ : Mul M
M' : Type u_2
inst✝ : Mul M'
⊢ ↑(Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 ∧ (p.1 * p.2).2 = (p.2 * p.1).2 }) /
      (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ^ 2) =
    ↑(Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } × { p // p.1 * p.2 = p.2 * p.1 })) /
      (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ^ 2)

tactic: congr 2
state_before: M : Type u_1
inst✝¹ : Mul M
M' : Type u_2
inst✝ : Mul M'
⊢ ↑(Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 ∧ (p.1 * p.2).2 = (p.2 * p.1).2 }) /
      (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ^ 2) =
    ↑(Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } × { p // p.1 * p.2 = p.2 * p.1 })) /
      (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ^ 2)
state_after: case e_a.e_a
M : Type u_1
inst✝¹ : Mul M
M' : Type u_2
inst✝ : Mul M'
⊢ Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 ∧ (p.1 * p.2).2 = (p.2 * p.1).2 } =
    Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } × { p // p.1 * p.2 = p.2 * p.1 })

tactic: exact Nat.card_congr ⟨fun x => ⟨⟨⟨x.1.1.1, x.1.2.1⟩, x.2.1⟩, ⟨⟨x.1.1.2, x.1.2.2⟩, x.2.2⟩⟩,
  fun x => ⟨⟨⟨x.1.1.1, x.2.1.1⟩, ⟨x.1.1.2, x.2.1.2⟩⟩, ⟨x.1.2, x.2.2⟩⟩, fun x => rfl, fun x => rfl⟩
state_before: case e_a.e_a
M : Type u_1
inst✝¹ : Mul M
M' : Type u_2
inst✝ : Mul M'
⊢ Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 ∧ (p.1 * p.2).2 = (p.2 * p.1).2 } =
    Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } × { p // p.1 * p.2 = p.2 * p.1 })
state_after: no goals
Theorem: ProbabilityTheory.measure_zero_or_one_of_measurableSet_limsup_atTop
File: Mathlib/Probability/Independence/ZeroOne.lean

tactic: simpa only [ae_dirac_eq, Filter.eventually_pure]
  using kernel.measure_zero_or_one_of_measurableSet_limsup_atTop h_le h_indep ht_tail
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μα : Measure α
μ : Measure Ω
inst✝⁴ : IsMarkovKernel κ
inst✝³ : IsProbabilityMeasure μ
inst✝² : SemilatticeSup ι
inst✝¹ : NoMaxOrder ι
inst✝ : Nonempty ι
h_le : ∀ (n : ι), s n ≤ m0
h_indep : iIndep s μ
t : Set Ω
ht_tail : MeasurableSet t
⊢ μ t = 0 ∨ μ t = 1
state_after: no goals
Theorem: concaveOn_id
File: Mathlib/Analysis/Convex/Function.lean

tactic: intros
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : SMul 𝕜 α
inst✝ : SMul 𝕜 β
s✝ : Set E
f : E → β
g : β → α
s : Set β
hs : Convex 𝕜 s
⊢ ∀ ⦃x : β⦄,
    x ∈ s →
      ∀ ⦃y : β⦄,
        y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → a • _root_.id x + b • _root_.id y ≤ _root_.id (a • x + b • y)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : SMul 𝕜 α
inst✝ : SMul 𝕜 β
s✝ : Set E
f : E → β
g : β → α
s : Set β
hs : Convex 𝕜 s
x✝ : β
a✝⁵ : x✝ ∈ s
y✝ : β
a✝⁴ : y✝ ∈ s
a✝³ b✝ : 𝕜
a✝² : 0 ≤ a✝³
a✝¹ : 0 ≤ b✝
a✝ : a✝³ + b✝ = 1
⊢ a✝³ • _root_.id x✝ + b✝ • _root_.id y✝ ≤ _root_.id (a✝³ • x✝ + b✝ • y✝)

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : SMul 𝕜 α
inst✝ : SMul 𝕜 β
s✝ : Set E
f : E → β
g : β → α
s : Set β
hs : Convex 𝕜 s
x✝ : β
a✝⁵ : x✝ ∈ s
y✝ : β
a✝⁴ : y✝ ∈ s
a✝³ b✝ : 𝕜
a✝² : 0 ≤ a✝³
a✝¹ : 0 ≤ b✝
a✝ : a✝³ + b✝ = 1
⊢ a✝³ • _root_.id x✝ + b✝ • _root_.id y✝ ≤ _root_.id (a✝³ • x✝ + b✝ • y✝)
state_after: no goals
Theorem: CircleDeg1Lift.units_semiconj_of_translationNumber_eq
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp [h]
state_before: f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
n : Multiplicative ℤ
⊢ τ (((Units.coeHom CircleDeg1Lift).comp ((zpowersHom CircleDeg1Liftˣ) f₁)) n) =
    τ (((Units.coeHom CircleDeg1Lift).comp ((zpowersHom CircleDeg1Liftˣ) f₂)) n)
state_after: no goals

tactic: simpa using hF (Multiplicative.ofAdd 1)
state_before: f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
this :
  ∀ (n : Multiplicative ℤ),
    τ (((Units.coeHom CircleDeg1Lift).comp ((zpowersHom CircleDeg1Liftˣ) f₁)) n) =
      τ (((Units.coeHom CircleDeg1Lift).comp ((zpowersHom CircleDeg1Liftˣ) f₂)) n)
F : CircleDeg1Lift
hF :
  ∀ (g : Multiplicative ℤ),
    Semiconj ⇑F ⇑(((Units.coeHom CircleDeg1Lift).comp ((zpowersHom CircleDeg1Liftˣ) f₁)) g)
      ⇑(((Units.coeHom CircleDeg1Lift).comp ((zpowersHom CircleDeg1Liftˣ) f₂)) g)
⊢ Semiconj ⇑F ⇑↑f₁ ⇑↑f₂
state_after: no goals
Theorem: HasDerivWithinAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simpa only [aux] using (hf.hasFDerivWithinAt.cpow hg h0).hasDerivWithinAt
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x c : ℂ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h0 : f x ∈ slitPlane
⊢ HasDerivWithinAt (fun x => f x ^ g x) (g x * f x ^ (g x - 1) * f' + f x ^ g x * Complex.log (f x) * g') s x
state_after: no goals
Theorem: Mathlib.Meta.NormNum.Finset.prod_empty
File: Mathlib/Tactic/NormNum/BigOperators.lean

tactic: simp
state_before: β : Type u_1
α : Type u_2
inst✝ : CommSemiring β
f : α → β
⊢ ∅.prod f = ↑1
state_after: no goals
Theorem: inner_neg_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← neg_one_smul 𝕜 x, inner_smul_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ⟪-x, y⟫_𝕜 = -⟪x, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ (starRingEnd 𝕜) (-1) * ⟪x, y⟫_𝕜 = -⟪x, y⟫_𝕜

tactic: simp
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ (starRingEnd 𝕜) (-1) * ⟪x, y⟫_𝕜 = -⟪x, y⟫_𝕜
state_after: no goals
Theorem: MeasureTheory.integral_union_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: simp only [IntegrableOn, Measure.restrict_union₀ hst ht, integral_add_measure hfs hft]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hst : AEDisjoint μ s t
ht : NullMeasurableSet t μ
hfs : IntegrableOn f s μ
hft : IntegrableOn f t μ
⊢ ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ + ∫ (x : X) in t, f x ∂μ
state_after: no goals
Theorem: continuousAt_const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: have cpow_eq : (fun x : ℂ => a ^ x) = fun x => exp (log a * x) := by
  ext1 b
  rw [cpow_def_of_ne_zero ha]
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
⊢ ContinuousAt (fun x => a ^ x) b
state_after: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => a ^ x) b

tactic: rw [cpow_eq]
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => a ^ x) b
state_after: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => cexp (Complex.log a * x)) b

tactic: exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
⊢ ContinuousAt (fun x => cexp (Complex.log a * x)) b
state_after: no goals

tactic: ext1 b
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
⊢ (fun x => a ^ x) = fun x => cexp (Complex.log a * x)
state_after: case h
α : Type u_1
a b✝ : ℂ
ha : a ≠ 0
b : ℂ
⊢ a ^ b = cexp (Complex.log a * b)

tactic: rw [cpow_def_of_ne_zero ha]
state_before: case h
α : Type u_1
a b✝ : ℂ
ha : a ≠ 0
b : ℂ
⊢ a ^ b = cexp (Complex.log a * b)
state_after: no goals
Theorem: UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: by_cases hcases : a = 0
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
⊢ p ∣ a
state_after: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : a = 0
⊢ p ∣ a

case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : ¬a = 0
⊢ p ∣ a

tactic: rw [hcases]
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : a = 0
⊢ p ∣ a
state_after: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : a = 0
⊢ p ∣ 0

tactic: exact dvd_zero p
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : a = 0
⊢ p ∣ 0
state_after: no goals

tactic: exact dvd_trans (Multiset.dvd_prod H) (Associated.dvd (normalizedFactors_prod hcases))
state_before: case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : ¬a = 0
⊢ p ∣ a
state_after: no goals
Theorem: Int.isUnit_sq
File: Mathlib/Data/Int/Order/Units.lean

tactic: rw [sq, isUnit_mul_self ha]
state_before: a : ℤ
ha : IsUnit a
⊢ a ^ 2 = 1
state_after: no goals
Theorem: Int.odd_coe_nat
File: Mathlib/Algebra/Ring/Int.lean

tactic: rw [odd_iff_not_even, Nat.odd_iff_not_even, even_coe_nat]
state_before: m n✝ : ℤ
n : ℕ
⊢ Odd ↑n ↔ Odd n
state_after: no goals
Theorem: PiNat.dist_self
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp [dist]
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
⊢ dist x x = 0
state_after: no goals
Theorem: factorization_one
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp [factorization]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
⊢ factorization 1 = 0
state_after: no goals
Theorem: strongConcaveOn_zero
File: Mathlib/Analysis/Convex/Strong.lean

tactic: simp [StrongConcaveOn, ← Pi.zero_def]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s✝ : Set E
a b m✝ : ℝ
x y : E
f✝ g : E → ℝ
s : Set E
f : E → ℝ
m n : ℝ
⊢ StrongConcaveOn s 0 f ↔ ConcaveOn ℝ s f
state_after: no goals
Theorem: Substring.ValidFor.valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp
state_before: l m r : List Char
⊢ l ++ (m ++ r) =
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.startPos.byteIdx =
      utf8Len l
state_after: no goals

tactic: simp
state_before: l m r : List Char
⊢ l ++ m ++ r =
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.stopPos.byteIdx =
      utf8Len (l ++ m)
state_after: no goals
Theorem: Monoid.Coprod.mrange_eq
File: Mathlib/GroupTheory/Coprod/Basic.lean

tactic: rw [MonoidHom.mrange_eq_map, ← mrange_inl_sup_mrange_inr, Submonoid.map_sup, MonoidHom.map_mrange,
  MonoidHom.map_mrange]
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
P : Type u_5
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass M'
inst✝¹ : MulOneClass N'
inst✝ : MulOneClass P
f : M ∗ N →* P
⊢ MonoidHom.mrange f = MonoidHom.mrange (f.comp inl) ⊔ MonoidHom.mrange (f.comp inr)
state_after: no goals
Theorem: AlgebraicGeometry.IsAffineOpen.fromSpec_preimage_self
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: ext1
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ hU.fromSpec ⁻¹ᵁ U = ⊤
state_after: case h
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ↑(hU.fromSpec ⁻¹ᵁ U) = ↑⊤

tactic: rw [Opens.map_coe, Opens.coe_top, ← hU.range_fromSpec, ← Set.image_univ]
state_before: case h
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ↑(hU.fromSpec ⁻¹ᵁ U) = ↑⊤
state_after: case h
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ⇑hU.fromSpec.val.base ⁻¹' (⇑hU.fromSpec.val.base '' Set.univ) = Set.univ

tactic: exact Set.preimage_image_eq _ PresheafedSpace.IsOpenImmersion.base_open.inj
state_before: case h
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ⇑hU.fromSpec.val.base ⁻¹' (⇑hU.fromSpec.val.base '' Set.univ) = Set.univ
state_after: no goals
Theorem: FractionalIdeal.spanSingleton_div_spanSingleton
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [div_spanSingleton, mul_comm, spanSingleton_mul_spanSingleton, div_eq_mul_inv]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x y : K
⊢ spanSingleton R₁⁰ x / spanSingleton R₁⁰ y = spanSingleton R₁⁰ (x / y)
state_after: no goals
Theorem: List.splitWrtCompositionAux_cons
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: simp [splitWrtCompositionAux]
state_before: n✝ : ℕ
α : Type u_1
l : List α
n : ℕ
ns : List ℕ
⊢ l.splitWrtCompositionAux (n :: ns) = take n l :: (drop n l).splitWrtCompositionAux ns
state_after: no goals
Theorem: Nat.Prime.multiplicity_factorial_mul
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: induction' n with n ih
state_before: n p : ℕ
hp : Prime p
⊢ multiplicity p (p * n)! = multiplicity p n ! + ↑n
state_after: case zero
p : ℕ
hp : Prime p
⊢ multiplicity p (p * 0)! = multiplicity p 0! + ↑0

case succ
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p (p * (n + 1))! = multiplicity p (n + 1)! + ↑(n + 1)

tactic: simp
state_before: case zero
p : ℕ
hp : Prime p
⊢ multiplicity p (p * 0)! = multiplicity p 0! + ↑0
state_after: no goals

tactic: simp only [succ_eq_add_one, multiplicity.mul, hp, hp.prime, ih, multiplicity_factorial_mul_succ,
  ← add_assoc, Nat.cast_one, Nat.cast_add, factorial_succ]
state_before: case succ
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p (p * (n + 1))! = multiplicity p (n + 1)! + ↑(n + 1)
state_after: case succ
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p n ! + ↑n + multiplicity p (n + 1) + 1 = multiplicity p (n + 1) + multiplicity p n ! + ↑n + 1

tactic: congr 1
state_before: case succ
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p n ! + ↑n + multiplicity p (n + 1) + 1 = multiplicity p (n + 1) + multiplicity p n ! + ↑n + 1
state_after: case succ.e_a
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p n ! + ↑n + multiplicity p (n + 1) = multiplicity p (n + 1) + multiplicity p n ! + ↑n

tactic: rw [add_comm, add_assoc]
state_before: case succ.e_a
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p n ! + ↑n + multiplicity p (n + 1) = multiplicity p (n + 1) + multiplicity p n ! + ↑n
state_after: no goals
Theorem: MeasureTheory.Lp.simpleFunc.toLp_sub
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp only [sub_eq_add_neg, ← toLp_neg, ← toLp_add]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : α →ₛ E
hf : Memℒp (↑f) p μ
hg : Memℒp (↑g) p μ
⊢ toLp (f - g) ⋯ = toLp f hf - toLp g hg
state_after: no goals