1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: DFinsupp.comapDomain_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
⊢ comapDomain h hh (single (h k) x) = single k x
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
⊢ (comapDomain h hh (single (h k) x)) i = (single k x) i

tactic: rw [comapDomain_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
⊢ (comapDomain h hh (single (h k) x)) i = (single k x) i
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
⊢ (single (h k) x) (h i) = (single k x) i

tactic: obtain rfl | hik := Decidable.eq_or_ne i k
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
⊢ (single (h k) x) (h i) = (single k x) i
state_after: case h.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
i : κ
x : β (h i)
⊢ (single (h i) x) (h i) = (single i x) i

case h.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
hik : i ≠ k
⊢ (single (h k) x) (h i) = (single k x) i

tactic: rw [single_eq_same, single_eq_same]
state_before: case h.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
i : κ
x : β (h i)
⊢ (single (h i) x) (h i) = (single i x) i
state_after: no goals

tactic: rw [single_eq_of_ne hik.symm, single_eq_of_ne (hh.ne hik.symm)]
state_before: case h.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
hik : i ≠ k
⊢ (single (h k) x) (h i) = (single k x) i
state_after: no goals
Theorem: WeierstrassCurve.map_φ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: simp only [φ, map_ψ]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (W.map f).φ n = Polynomial.map (mapRingHom f) (W.φ n)
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ C X * Polynomial.map (mapRingHom f) (W.ψ n) ^ 2 -
      Polynomial.map (mapRingHom f) (W.ψ (n + 1)) * Polynomial.map (mapRingHom f) (W.ψ (n - 1)) =
    Polynomial.map (mapRingHom f) (C X * W.ψ n ^ 2 - W.ψ (n + 1) * W.ψ (n - 1))

tactic: map_simp
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ C X * Polynomial.map (mapRingHom f) (W.ψ n) ^ 2 -
      Polynomial.map (mapRingHom f) (W.ψ (n + 1)) * Polynomial.map (mapRingHom f) (W.ψ (n - 1)) =
    Polynomial.map (mapRingHom f) (C X * W.ψ n ^ 2 - W.ψ (n + 1) * W.ψ (n - 1))
state_after: no goals
Theorem: AddCommGroup.self_modEq_zero
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ 0 - p = -1 • p
state_after: no goals
Theorem: Int.preimage_Iic
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ Int.cast ⁻¹' Iic a = Iic ⌊a⌋
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Iic a ↔ x✝ ∈ Iic ⌊a⌋

tactic: simp [le_floor]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Iic a ↔ x✝ ∈ Iic ⌊a⌋
state_after: no goals
Theorem: groupCohomology.map_one_snd_of_isMulTwoCocycle
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

tactic: simpa only [mul_one, mul_left_inj] using hf g 1 1
state_before: k G✝ : Type u
inst✝⁴ : CommRing k
inst✝³ : Group G✝
A : Rep k G✝
G : Type u_1
M : Type u_2
inst✝² : Monoid G
inst✝¹ : CommGroup M
inst✝ : MulAction G M
f : G × G → M
hf : IsMulTwoCocycle f
g : G
⊢ f (g, 1) = g • f (1, 1)
state_after: no goals
Theorem: Set.SurjOn.comp_left
File: Mathlib/Data/Set/Function.lean

tactic: rw [SurjOn, image_comp g f]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
g : β → γ
⊢ SurjOn (g ∘ f) s (g '' t)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
g : β → γ
⊢ g '' t ⊆ g '' (f '' s)

tactic: exact image_subset _ hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
g : β → γ
⊢ g '' t ⊆ g '' (f '' s)
state_after: no goals
Theorem: isAddFundamentalDomain_Ioc'
File: Mathlib/MeasureTheory/Integral/Periodic.lean

tactic: refine IsAddFundamentalDomain.mk' measurableSet_Ioc.nullMeasurableSet fun x => ?_
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
⊢ IsAddFundamentalDomain (↥(zmultiples T).op) (Ioc t (t + T)) μ
state_after: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)

tactic: have : Bijective (codRestrict (fun n : ℤ => n • T) (AddSubgroup.zmultiples T) _) :=
  (Equiv.ofInjective (fun n : ℤ => n • T) (zsmul_strictMono_left hT).injective).bijective
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)
state_after: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)

tactic: refine (AddSubgroup.equivOp _).bijective.comp this |>.existsUnique_iff.2 ?_
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)
state_after: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! x_1, (⇑(zmultiples T).equivOp ∘ codRestrict (fun n => n • T) ↑(zmultiples T) ⋯) x_1 +ᵥ x ∈ Ioc t (t + T)

tactic: simpa using existsUnique_add_zsmul_mem_Ioc hT x t
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! x_1, (⇑(zmultiples T).equivOp ∘ codRestrict (fun n => n • T) ↑(zmultiples T) ⋯) x_1 +ᵥ x ∈ Ioc t (t + T)
state_after: no goals
Theorem: MeasureTheory.Measure.setIntegral_toReal_rnDeriv'
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: rw [setIntegral_toReal_rnDeriv_eq_withDensity' hs, Measure.withDensity_rnDeriv_eq _ _ hμν]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
s : Set α
hs : MeasurableSet s
⊢ ∫ (x : α) in s, (μ.rnDeriv ν x).toReal ∂ν = (μ s).toReal
state_after: no goals
Theorem: UniformOnFun.precomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp_rw [UniformContinuous, UniformOnFun.uniformity_eq, tendsto_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
⊢ UniformContinuous fun g => (ofFun 𝔗) ((toFun 𝔖) g ∘ f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
⊢ ∀ i ∈ 𝔗,
    ∀ i_2 ∈ 𝓤 β,
      Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f)))
        (⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V)) (𝓟 (UniformOnFun.gen 𝔗 i i_2))

tactic: refine fun t ht V hV ↦ tendsto_iInf' (f '' t) <| tendsto_iInf' (hf ht) <|
  tendsto_iInf' V <| tendsto_iInf' hV ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
⊢ ∀ i ∈ 𝔗,
    ∀ i_2 ∈ 𝓤 β,
      Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f)))
        (⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V)) (𝓟 (UniformOnFun.gen 𝔗 i i_2))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
t : Set γ
ht : t ∈ 𝔗
V : Set (β × β)
hV : V ∈ 𝓤 β
⊢ Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f))) (𝓟 (UniformOnFun.gen 𝔖 (f '' t) V))
    (𝓟 (UniformOnFun.gen 𝔗 t V))

tactic: simpa only [tendsto_principal_principal, UniformOnFun.gen] using fun _ ↦ forall_mem_image.1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
t : Set γ
ht : t ∈ 𝔗
V : Set (β × β)
hV : V ∈ 𝓤 β
⊢ Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f))) (𝓟 (UniformOnFun.gen 𝔖 (f '' t) V))
    (𝓟 (UniformOnFun.gen 𝔗 t V))
state_after: no goals
Theorem: normEDS_four
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: erw [normEDS_ofNat, preNormEDS'_four, if_pos <| by decide]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ normEDS b c d 4 = d * b
state_after: no goals

tactic: decide
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ Even 4
state_after: no goals
Theorem: Real.deriv_mul_log
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

tactic: rw [deriv_mul differentiableAt_id' (differentiableAt_log hx)]
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x * log x) x = log x + 1
state_after: x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x) x * log x + x * deriv log x = log x + 1

tactic: simp only [deriv_id'', one_mul, deriv_log', ne_eq, add_right_inj]
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x) x * log x + x * deriv log x = log x + 1
state_after: x : ℝ
hx : x ≠ 0
⊢ x * x⁻¹ = 1

tactic: exact mul_inv_cancel hx
state_before: x : ℝ
hx : x ≠ 0
⊢ x * x⁻¹ = 1
state_after: no goals
Theorem: continuous_sigma_map
File: Mathlib/Topology/Constructions.lean

tactic: simp only [Sigma.map, embedding_sigmaMk.continuous_iff, comp]
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
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f₁ : ι → κ
f₂ : (i : ι) → σ i → τ (f₁ i)
⊢ (∀ (i : ι), Continuous fun a => Sigma.map f₁ f₂ ⟨i, a⟩) ↔ ∀ (i : ι), Continuous (f₂ i)
state_after: no goals
Theorem: Lagrange.sum_nodalWeight_mul_inv_sub_ne_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simpa only [Pi.one_apply, interpolate_one hvs hs, eval_one, mul_one] using
  (eval_interpolate_not_at_node 1 hx).symm
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hx : ∀ i ∈ s, x ≠ v i
hs : s.Nonempty
⊢ eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ = 1
state_after: no goals
Theorem: Complex.nndist_self_conj
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [nndist_comm, nndist_conj_self]
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℂ
⊢ nndist z ((starRingEnd ℂ) z) = 2 * Real.nnabs z.im
state_after: no goals
Theorem: Real.arccos_eq_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [arccos, eq_comm]
state_before: x : ℝ
h : 0 < x
⊢ arccos x = arctan (√(1 - x ^ 2) / x)
state_after: x : ℝ
h : 0 < x
⊢ arctan (√(1 - x ^ 2) / x) = π / 2 - arcsin x

tactic: refine arctan_eq_of_tan_eq ?_ ⟨?_, ?_⟩
state_before: x : ℝ
h : 0 < x
⊢ arctan (√(1 - x ^ 2) / x) = π / 2 - arcsin x
state_after: case refine_1
x : ℝ
h : 0 < x
⊢ tan (π / 2 - arcsin x) = √(1 - x ^ 2) / x

case refine_2
x : ℝ
h : 0 < x
⊢ -(π / 2) < π / 2 - arcsin x

case refine_3
x : ℝ
h : 0 < x
⊢ π / 2 - arcsin x < π / 2

tactic: rw_mod_cast [tan_pi_div_two_sub, tan_arcsin, inv_div]
state_before: case refine_1
x : ℝ
h : 0 < x
⊢ tan (π / 2 - arcsin x) = √(1 - x ^ 2) / x
state_after: no goals

tactic: linarith only [arcsin_le_pi_div_two x, pi_pos]
state_before: case refine_2
x : ℝ
h : 0 < x
⊢ -(π / 2) < π / 2 - arcsin x
state_after: no goals

tactic: linarith only [arcsin_pos.2 h]
state_before: case refine_3
x : ℝ
h : 0 < x
⊢ π / 2 - arcsin x < π / 2
state_after: no goals
Theorem: Ordinal.add_eq_zero_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp_rw [← type_sum_lex, type_eq_zero_iff_isEmpty]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type u_4
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ type r + type s = 0 ↔ type r = 0 ∧ type s = 0
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type u_4
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β

tactic: exact isEmpty_sum
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
α : Type u_4
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type u_4
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β
state_after: no goals
Theorem: ContinuousWithinAt.finset_sup'
File: Mathlib/Topology/Order/Lattice.lean

tactic: simpa only [← Finset.sup'_apply] using finset_sup'_apply hne hs
state_before: L : Type u_1
X : Type u_2
inst✝³ : TopologicalSpace L
inst✝² : TopologicalSpace X
ι : Type u_3
inst✝¹ : SemilatticeSup L
inst✝ : ContinuousSup L
s : Finset ι
f : ι → X → L
t : Set X
x : X
hne : s.Nonempty
hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x
⊢ ContinuousWithinAt (s.sup' hne f) t x
state_after: no goals
Theorem: Polynomial.support_map_subset
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: intro x
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X]
⊢ (map f p).support ⊆ p.support
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X]
x : ℕ
⊢ x ∈ (map f p).support → x ∈ p.support

tactic: contrapose!
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X]
x : ℕ
⊢ x ∈ (map f p).support → x ∈ p.support
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X]
x : ℕ
⊢ x ∉ p.support → x ∉ (map f p).support

tactic: simp (config := { contextual := true })
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X]
x : ℕ
⊢ x ∉ p.support → x ∉ (map f p).support
state_after: no goals
Theorem: Mathlib.Meta.NormNum.ble_eq_false
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [← Nat.not_le, ← Bool.not_eq_true, Nat.ble_eq]
state_before: x y : ℕ
⊢ x.ble y = false ↔ y < x
state_after: no goals
Theorem: ArithmeticFunction.sum_eq_iff_sum_smul_moebius_eq_on'
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: have : ∀ P : ℕ → Prop, ((∀ n ∈ s, P n) ↔ (∀ n > 0, n ∈ s → P n)) := fun P ↦ by
  refine forall_congr' (fun n ↦ ⟨fun h _ ↦ h, fun h hn ↦ h ?_ hn⟩)
  contrapose! hs₀
  simpa [nonpos_iff_eq_zero.mp hs₀] using hn
state_before: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
hs₀ : 0 ∉ s
⊢ (∀ n ∈ s, ∑ i ∈ n.divisors, f i = g n) ↔ ∀ n ∈ s, ∑ x ∈ n.divisorsAntidiagonal, μ x.1 • g x.2 = f n
state_after: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
hs₀ : 0 ∉ s
this : ∀ (P : ℕ → Prop), (∀ n ∈ s, P n) ↔ ∀ n > 0, n ∈ s → P n
⊢ (∀ n ∈ s, ∑ i ∈ n.divisors, f i = g n) ↔ ∀ n ∈ s, ∑ x ∈ n.divisorsAntidiagonal, μ x.1 • g x.2 = f n

tactic: simpa only [this] using sum_eq_iff_sum_smul_moebius_eq_on s hs
state_before: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
hs₀ : 0 ∉ s
this : ∀ (P : ℕ → Prop), (∀ n ∈ s, P n) ↔ ∀ n > 0, n ∈ s → P n
⊢ (∀ n ∈ s, ∑ i ∈ n.divisors, f i = g n) ↔ ∀ n ∈ s, ∑ x ∈ n.divisorsAntidiagonal, μ x.1 • g x.2 = f n
state_after: no goals

tactic: refine forall_congr' (fun n ↦ ⟨fun h _ ↦ h, fun h hn ↦ h ?_ hn⟩)
state_before: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
hs₀ : 0 ∉ s
P : ℕ → Prop
⊢ (∀ n ∈ s, P n) ↔ ∀ n > 0, n ∈ s → P n
state_after: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
hs₀ : 0 ∉ s
P : ℕ → Prop
n : ℕ
h : n > 0 → n ∈ s → P n
hn : n ∈ s
⊢ n > 0

tactic: contrapose! hs₀
state_before: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
hs₀ : 0 ∉ s
P : ℕ → Prop
n : ℕ
h : n > 0 → n ∈ s → P n
hn : n ∈ s
⊢ n > 0
state_after: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
P : ℕ → Prop
n : ℕ
h : n > 0 → n ∈ s → P n
hn : n ∈ s
hs₀ : n ≤ 0
⊢ 0 ∈ s

tactic: simpa [nonpos_iff_eq_zero.mp hs₀] using hn
state_before: R : Type u_1
inst✝ : AddCommGroup R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
P : ℕ → Prop
n : ℕ
h : n > 0 → n ∈ s → P n
hn : n ∈ s
hs₀ : n ≤ 0
⊢ 0 ∈ s
state_after: no goals
Theorem: CategoryTheory.types_ext
File: Mathlib/CategoryTheory/Types.lean

tactic: funext x
state_before: α β : Type u
f g : α ⟶ β
h : ∀ (a : α), f a = g a
⊢ f = g
state_after: case h
α β : Type u
f g : α ⟶ β
h : ∀ (a : α), f a = g a
x : α
⊢ f x = g x

tactic: exact h x
state_before: case h
α β : Type u
f g : α ⟶ β
h : ∀ (a : α), f a = g a
x : α
⊢ f x = g x
state_after: no goals
Theorem: antivary_inv₀
File: Mathlib/Algebra/Order/Monovary.lean

tactic: rw [antivary_inv_left₀ hf, monovary_inv_right₀ hg]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : LinearOrderedSemifield β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
hf : StrongLT 0 f
hg : StrongLT 0 g
⊢ Antivary f⁻¹ g⁻¹ ↔ Antivary f g
state_after: no goals
Theorem: Subtype.range_coe
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_univ]
state_before: α : Type u_1
s : Set α
⊢ range val = s
state_after: α : Type u_1
s : Set α
⊢ val '' univ = s

tactic: simp [-image_univ, coe_image]
state_before: α : Type u_1
s : Set α
⊢ val '' univ = s
state_after: no goals
Theorem: Finset.mem_prod_list_ofFn
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← mem_coe, coe_list_prod, List.map_ofFn, Set.mem_prod_list_ofFn]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s✝ t : Finset α
a✝ : α
m n : ℕ
a : α
s : Fin n → Finset α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s✝ t : Finset α
a✝ : α
m n : ℕ
a : α
s : Fin n → Finset α
⊢ (∃ f, (List.ofFn fun i => ↑(f i)).prod = a) ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

tactic: rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s✝ t : Finset α
a✝ : α
m n : ℕ
a : α
s : Fin n → Finset α
⊢ (∃ f, (List.ofFn fun i => ↑(f i)).prod = a) ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
state_after: no goals
Theorem: forall_restrictGermPredicate_iff
File: Mathlib/Topology/Germ.lean

tactic: rw [eventually_nhdsSet_iff_forall]
state_before: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x : X
P : (x : X) → (𝓝 x).Germ Y → Prop
⊢ (∀ (x : X), RestrictGermPredicate P A x ↑f) ↔ ∀ᶠ (x : X) in 𝓝ˢ A, P x ↑f
state_after: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x : X
P : (x : X) → (𝓝 x).Germ Y → Prop
⊢ (∀ (x : X), RestrictGermPredicate P A x ↑f) ↔ ∀ x ∈ A, ∀ᶠ (y : X) in 𝓝 x, P y ↑f

tactic: rfl
state_before: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x : X
P : (x : X) → (𝓝 x).Germ Y → Prop
⊢ (∀ (x : X), RestrictGermPredicate P A x ↑f) ↔ ∀ x ∈ A, ∀ᶠ (y : X) in 𝓝 x, P y ↑f
state_after: no goals
Theorem: Finset.nontrivial_prod_iff
File: Mathlib/Data/Finset/Prod.lean

tactic: simp_rw [← card_pos, ← one_lt_card_iff_nontrivial, card_product]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
⊢ (s ×ˢ t).Nontrivial ↔ s.Nonempty ∧ t.Nonempty ∧ (s.Nontrivial ∨ t.Nontrivial)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
⊢ 1 < s.card * t.card ↔ 0 < s.card ∧ 0 < t.card ∧ (1 < s.card ∨ 1 < t.card)

tactic: apply Nat.one_lt_mul_iff
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
⊢ 1 < s.card * t.card ↔ 0 < s.card ∧ 0 < t.card ∧ (1 < s.card ∨ 1 < t.card)
state_after: no goals
Theorem: OreLocalization.smul_cancel
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_smul_char s.1 r t s 1 1 (by simp)]
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r : X
s t : ↥S
⊢ (↑s /ₒ t) • (r /ₒ s) = r /ₒ t
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r : X
s t : ↥S
⊢ ↑1 * ↑s = 1 * ↑s
state_after: no goals
Theorem: CategoryTheory.Limits.inr_pushoutAssoc_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← Iso.eq_comp_inv, Category.assoc, inr_inr_pushoutAssoc_inv]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom = pushout.inr ≫ pushout.inr
state_after: no goals