1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.FiniteMeasure.map_prod_map
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

tactic: apply Subtype.ext
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
β : Type u_2
inst✝² : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
α' : Type u_3
inst✝¹ : MeasurableSpace α'
β' : Type u_4
inst✝ : MeasurableSpace β'
f : α → α'
g : β → β'
f_mble : Measurable f
g_mble : Measurable g
⊢ (μ.map f).prod (ν.map g) = (μ.prod ν).map (Prod.map f g)
state_after: case a
α : Type u_1
inst✝³ : MeasurableSpace α
β : Type u_2
inst✝² : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
α' : Type u_3
inst✝¹ : MeasurableSpace α'
β' : Type u_4
inst✝ : MeasurableSpace β'
f : α → α'
g : β → β'
f_mble : Measurable f
g_mble : Measurable g
⊢ ↑((μ.map f).prod (ν.map g)) = ↑((μ.prod ν).map (Prod.map f g))

tactic: simp only [val_eq_toMeasure, toMeasure_prod, toMeasure_map]
state_before: case a
α : Type u_1
inst✝³ : MeasurableSpace α
β : Type u_2
inst✝² : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
α' : Type u_3
inst✝¹ : MeasurableSpace α'
β' : Type u_4
inst✝ : MeasurableSpace β'
f : α → α'
g : β → β'
f_mble : Measurable f
g_mble : Measurable g
⊢ ↑((μ.map f).prod (ν.map g)) = ↑((μ.prod ν).map (Prod.map f g))
state_after: case a
α : Type u_1
inst✝³ : MeasurableSpace α
β : Type u_2
inst✝² : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
α' : Type u_3
inst✝¹ : MeasurableSpace α'
β' : Type u_4
inst✝ : MeasurableSpace β'
f : α → α'
g : β → β'
f_mble : Measurable f
g_mble : Measurable g
⊢ (Measure.map f ↑μ).prod (Measure.map g ↑ν) = Measure.map (Prod.map f g) ((↑μ).prod ↑ν)

tactic: rw [Measure.map_prod_map _ _ f_mble g_mble]
state_before: case a
α : Type u_1
inst✝³ : MeasurableSpace α
β : Type u_2
inst✝² : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
α' : Type u_3
inst✝¹ : MeasurableSpace α'
β' : Type u_4
inst✝ : MeasurableSpace β'
f : α → α'
g : β → β'
f_mble : Measurable f
g_mble : Measurable g
⊢ (Measure.map f ↑μ).prod (Measure.map g ↑ν) = Measure.map (Prod.map f g) ((↑μ).prod ↑ν)
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.autMulEquivAutGalois_π
File: Mathlib/CategoryTheory/Galois/Prorepresentability.lean

tactic: dsimp [autMulEquivAutGalois, endMulEquivAutGalois]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ F.map ((AutGalois.π F { obj := A, pt := a, isGalois := ⋯ }) (MulOpposite.unop ((autMulEquivAutGalois F) f))).hom a =
    f.hom.app A a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ F.map
      ((AutGalois.π F { obj := A, pt := a, isGalois := ⋯ })
          ((endEquivAutGalois F) ↑((Aut.unitsEndEquivAut F).symm f))).hom
      a =
    f.hom.app A a

tactic: rw [endEquivAutGalois_π]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ F.map
      ((AutGalois.π F { obj := A, pt := a, isGalois := ⋯ })
          ((endEquivAutGalois F) ↑((Aut.unitsEndEquivAut F).symm f))).hom
      a =
    f.hom.app A a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ (↑((Aut.unitsEndEquivAut F).symm f)).app { obj := A, pt := a, isGalois := ⋯ }.obj
      { obj := A, pt := a, isGalois := ⋯ }.pt =
    f.hom.app A a

tactic: rfl
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ (↑((Aut.unitsEndEquivAut F).symm f)).app { obj := A, pt := a, isGalois := ⋯ }.obj
      { obj := A, pt := a, isGalois := ⋯ }.pt =
    f.hom.app A a
state_after: no goals
Theorem: Function.Semiconj.symm_adjoint
File: Mathlib/Order/SemiconjSup.lean

tactic: refine fun y => (hg' _).unique ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
⊢ Semiconj g' ⇑fb ⇑fa
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB {x | g x ≤ fb y} (fa (g' y))

tactic: rw [← fa.surjective.image_preimage { x | g x ≤ fb y }, preimage_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB {x | g x ≤ fb y} (fa (g' y))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB (⇑fa '' {a | g (fa a) ≤ fb y}) (fa (g' y))

tactic: simp only [h.eq, fb.le_iff_le, fa.leftOrdContinuous (hg' _)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB (⇑fa '' {a | g (fa a) ≤ fb y}) (fa (g' y))
state_after: no goals
Theorem: Stream'.WSeq.map_ret
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [ret]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
⊢ map f (ret a) = ret (f a)
state_after: no goals
Theorem: NonUnitalSubring.prod_top
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_fst]
state_before: F : Type w
R : Type u
S : Type v
T : Type u_1
inst✝⁴ : NonUnitalNonAssocRing R
inst✝³ : NonUnitalNonAssocRing S
inst✝² : NonUnitalNonAssocRing T
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
g : S →ₙ+* T
f : R →ₙ+* S
s : NonUnitalSubring R
x : R × S
⊢ x ∈ s.prod ⊤ ↔ x ∈ comap (NonUnitalRingHom.fst R S) s
state_after: no goals
Theorem: Set.uIcc_prod_eq
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Lattice α
inst✝ : Lattice β
a✝ a₁ a₂ b✝ b₁ b₂ c x : α
a b : α × β
⊢ [[a, b]] = [[a.1, b.1]] ×ˢ [[a.2, b.2]]
state_after: no goals
Theorem: PartENat.toWithTop_natCast
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp only [← toWithTop_some]
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = ↑n
state_after: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = (↑n).toWithTop

tactic: congr
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = (↑n).toWithTop
state_after: no goals
Theorem: closedBall_add_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [add_comm, ball_add_closedBall hδ hε b, add_comm, add_comm δ]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 ≤ ε
hδ : 0 < δ
a b : E
⊢ Metric.closedBall a ε + Metric.ball b δ = Metric.ball (a + b) (ε + δ)
state_after: no goals
Theorem: TensorProduct.ext
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: rw [← lift_mk_compr₂ g, H, lift_mk_compr₂]
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
f : M →ₗ[R] N →ₗ[R] P
g h : M ⊗[R] N →ₗ[R] P
H : (mk R M N).compr₂ g = (mk R M N).compr₂ h
⊢ g = h
state_after: no goals
Theorem: Set.Ioc_union_Ioc_symm
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [max_comm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b a = Ioc (min a b) (max a b)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b a = Ioc (min a b) (max b a)

tactic: apply Ioc_union_Ioc <;> rw [max_comm] <;> exact min_le_max
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b a = Ioc (min a b) (max b a)
state_after: no goals
Theorem: pi_eq_generateFrom
File: Mathlib/Topology/Constructions.lean

tactic: simp only [generateFrom_setOf_isOpen]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
⊢ Pi.topologicalSpace = Pi.topologicalSpace
state_after: no goals
Theorem: Polynomial.smeval_zero
File: Mathlib/Algebra/Polynomial/Smeval.lean

tactic: simp only [smeval_eq_sum, smul_pow, sum_zero_index]
state_before: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ smeval 0 x = 0
state_after: no goals
Theorem: LinearMap.restrict_sub
File: Mathlib/Algebra/Module/Submodule/LinearMap.lean

tactic: ext
state_before: R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M✝ : Type u_5
M₁✝ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
ι : Type u_9
inst✝¹⁶ : Semiring R✝
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
inst✝¹³ : AddCommMonoid M✝
inst✝¹² : AddCommMonoid M₁✝
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : Module R✝ M✝
inst✝⁸ : Module R✝ M₁✝
inst✝⁷ : Module R₂ M₂
inst✝⁶ : Module R₃ M₃
σ₁₂ : R✝ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R✝ →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
f✝ : M✝ →ₛₗ[σ₁₂] M₂
g✝ : M₂ →ₛₗ[σ₂₃] M₃
R : Type u_10
M : Type u_11
M₁ : Type u_12
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M
inst✝ : Module R M₁
p : Submodule R M
q : Submodule R M₁
f g : M →ₗ[R] M₁
hf : MapsTo ⇑f ↑p ↑q
hg : MapsTo ⇑g ↑p ↑q
hfg : optParam (MapsTo ⇑(f - g) ↑p ↑q) ⋯
⊢ f.restrict hf - g.restrict hg = (f - g).restrict hfg
state_after: case h.a
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M✝ : Type u_5
M₁✝ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
ι : Type u_9
inst✝¹⁶ : Semiring R✝
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
inst✝¹³ : AddCommMonoid M✝
inst✝¹² : AddCommMonoid M₁✝
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : Module R✝ M✝
inst✝⁸ : Module R✝ M₁✝
inst✝⁷ : Module R₂ M₂
inst✝⁶ : Module R₃ M₃
σ₁₂ : R✝ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R✝ →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
f✝ : M✝ →ₛₗ[σ₁₂] M₂
g✝ : M₂ →ₛₗ[σ₂₃] M₃
R : Type u_10
M : Type u_11
M₁ : Type u_12
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M
inst✝ : Module R M₁
p : Submodule R M
q : Submodule R M₁
f g : M →ₗ[R] M₁
hf : MapsTo ⇑f ↑p ↑q
hg : MapsTo ⇑g ↑p ↑q
hfg : optParam (MapsTo ⇑(f - g) ↑p ↑q) ⋯
x✝ : ↥p
⊢ ↑((f.restrict hf - g.restrict hg) x✝) = ↑(((f - g).restrict hfg) x✝)

tactic: simp
state_before: case h.a
R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M✝ : Type u_5
M₁✝ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
ι : Type u_9
inst✝¹⁶ : Semiring R✝
inst✝¹⁵ : Semiring R₂
inst✝¹⁴ : Semiring R₃
inst✝¹³ : AddCommMonoid M✝
inst✝¹² : AddCommMonoid M₁✝
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : Module R✝ M✝
inst✝⁸ : Module R✝ M₁✝
inst✝⁷ : Module R₂ M₂
inst✝⁶ : Module R₃ M₃
σ₁₂ : R✝ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R✝ →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
f✝ : M✝ →ₛₗ[σ₁₂] M₂
g✝ : M₂ →ₛₗ[σ₂₃] M₃
R : Type u_10
M : Type u_11
M₁ : Type u_12
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M
inst✝ : Module R M₁
p : Submodule R M
q : Submodule R M₁
f g : M →ₗ[R] M₁
hf : MapsTo ⇑f ↑p ↑q
hg : MapsTo ⇑g ↑p ↑q
hfg : optParam (MapsTo ⇑(f - g) ↑p ↑q) ⋯
x✝ : ↥p
⊢ ↑((f.restrict hf - g.restrict hg) x✝) = ↑(((f - g).restrict hfg) x✝)
state_after: no goals
Theorem: Filter.tendsto_comap'_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [Tendsto, ← map_compose]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ (map m ∘ map i) (comap i f) ≤ g ↔ Tendsto m f g
Theorem: Finmap.erase_union_singleton
File: Mathlib/Data/Finmap.lean

tactic: by_cases h' : x = a
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s
state_after: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : x = a
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

tactic: subst a
state_before: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : x = a
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s
state_after: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : α
b : β x
h : lookup x s = some b
⊢ lookup x (erase x s ∪ singleton x b) = lookup x s

tactic: rw [lookup_union_right not_mem_erase_self, lookup_singleton_eq, h]
state_before: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : α
b : β x
h : lookup x s = some b
⊢ lookup x (erase x s ∪ singleton x b) = lookup x s
state_after: no goals

tactic: have : x ∉ singleton a b := by rwa [mem_singleton]
state_before: case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s
state_after: case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
this : x ∉ singleton a b
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

tactic: rw [lookup_union_left_of_not_in this, lookup_erase_ne h']
state_before: case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
this : x ∉ singleton a b
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s
state_after: no goals

tactic: rwa [mem_singleton]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
⊢ x ∉ singleton a b
state_after: no goals
Theorem: LocalizedModule.add_zero'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [← zero_mk s, mk_add_mk, smul_zero, add_zero, mk_eq]
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ mk m s + 0 = mk m s
state_after: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ ∃ u, u • s • s • m = u • (s * s) • m

tactic: exact ⟨1, by rw [one_smul, mul_smul, one_smul]⟩
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ ∃ u, u • s • s • m = u • (s * s) • m
state_after: no goals

tactic: rw [one_smul, mul_smul, one_smul]
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ 1 • s • s • m = 1 • (s * s) • m
state_after: no goals
Theorem: CategoryTheory.OplaxNatTrans.whiskerLeft_naturality_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality_naturality]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ (↑G.toPrelaxFunctor).obj a
g h : a ⟶ b
β : g ⟶ h
⊢ f ◁ G.map₂ β ▷ θ.app b ≫ f ◁ θ.naturality h = f ◁ θ.naturality g ≫ f ◁ θ.app a ◁ H.map₂ β
state_after: no goals
Theorem: ProjectiveSpectrum.vanishingIdeal_singleton
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simp [vanishingIdeal]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : ProjectiveSpectrum 𝒜
⊢ vanishingIdeal {x} = x.asHomogeneousIdeal
state_after: no goals
Theorem: AdjoinRoot.Minpoly.toAdjoin.apply_X
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: simp [toAdjoin]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
⊢ (toAdjoin R x) ((mk (minpoly R x)) X) = ⟨x, ⋯⟩
state_after: no goals
Theorem: Set.toFinset_Iio
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: ext
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderBot α
a : α
inst✝ : Fintype ↑(Iio a)
⊢ (Iio a).toFinset = Finset.Iio a
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderBot α
a : α
inst✝ : Fintype ↑(Iio a)
a✝ : α
⊢ a✝ ∈ (Iio a).toFinset ↔ a✝ ∈ Finset.Iio a

tactic: simp
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderBot α
a : α
inst✝ : Fintype ↑(Iio a)
a✝ : α
⊢ a✝ ∈ (Iio a).toFinset ↔ a✝ ∈ Finset.Iio a
state_after: no goals
Theorem: Equiv.Perm.support_le_prod_of_mem
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: intro x hx
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
⊢ f.support ≤ l.prod.support
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
x : α
hx : x ∈ f.support
⊢ x ∈ l.prod.support

tactic: rwa [mem_support, ← eq_on_support_mem_disjoint h hl _ hx, ← mem_support]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
x : α
hx : x ∈ f.support
⊢ x ∈ l.prod.support
state_after: no goals
Theorem: GaussianInt.norm_le_norm_mul_left
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

tactic: rw [Zsqrtd.norm_mul, Int.natAbs_mul]
state_before: x y : ℤ[i]
hy : y ≠ 0
⊢ (norm x).natAbs ≤ (norm (x * y)).natAbs
state_after: x y : ℤ[i]
hy : y ≠ 0
⊢ (norm x).natAbs ≤ (norm x).natAbs * (norm y).natAbs

tactic: exact le_mul_of_one_le_right (Nat.zero_le _) (Int.ofNat_le.1 (by
  rw [abs_natCast_norm]
  exact Int.add_one_le_of_lt (norm_pos.2 hy)))
state_before: x y : ℤ[i]
hy : y ≠ 0
⊢ (norm x).natAbs ≤ (norm x).natAbs * (norm y).natAbs
state_after: no goals

tactic: rw [abs_natCast_norm]
state_before: x y : ℤ[i]
hy : y ≠ 0
⊢ ↑1 ≤ ↑(norm y).natAbs
state_after: x y : ℤ[i]
hy : y ≠ 0
⊢ ↑1 ≤ norm y

tactic: exact Int.add_one_le_of_lt (norm_pos.2 hy)
state_before: x y : ℤ[i]
hy : y ≠ 0
⊢ ↑1 ≤ norm y
state_after: no goals
Theorem: CategoryTheory.IsKernelPair.of_isIso_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean

tactic: change IsPullback _ _ _ _
state_before: C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ IsKernelPair f a a
state_after: C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ IsPullback a a f f

tactic: convert (IsPullback.of_horiz_isIso ⟨(rfl : a ≫ 𝟙 X = _ )⟩).paste_vert (IsKernelPair.id_of_mono f)
state_before: C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ IsPullback a a f f
state_after: case h.e'_8
C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ a = a ≫ 𝟙 X

case h.e'_9
C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ f = 𝟙 X ≫ f

tactic: all_goals { simp }
state_before: case h.e'_8
C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ a = a ≫ 𝟙 X

case h.e'_9
C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ f = 𝟙 X ≫ f
state_after: no goals

tactic: simp
state_before: case h.e'_9
C : Type u
inst✝² : Category.{v, u} C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ f = 𝟙 X ≫ f
state_after: no goals
Theorem: Ordinal.lift.principalSeg_top'
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp only [lift.principalSeg_top, univ_id]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ principalSeg.top = type fun x x_1 => x < x_1
state_after: no goals
Theorem: toIcoMod_apply_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod_eq_iff hp, Set.left_mem_Ico]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ toIcoMod hp a a = a
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a = a + z • p

tactic: exact ⟨lt_add_of_pos_right _ hp, 0, by simp⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a = a + z • p
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a = a + 0 • p
state_after: no goals
Theorem: Stream'.WSeq.toList_ofList
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction' l with a l IH <;> simp [ret_mem]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ l ∈ (↑l).toList
state_after: case cons
α : Type u
β : Type v
γ : Type w
a : α
l : List α
IH : l ∈ (↑l).toList
⊢ a :: l ∈ (List.cons a <$> (↑l).toList).think

tactic: exact think_mem (Computation.mem_map _ IH)
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
l : List α
IH : l ∈ (↑l).toList
⊢ a :: l ∈ (List.cons a <$> (↑l).toList).think
state_after: no goals