1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.toColex_inj
File: Mathlib/Combinatorics/Colex.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
s t : Finset α
⊢ { ofColex := s } = { ofColex := t } ↔ s = t
state_after: no goals
Theorem: Batteries.UnionFind.parentD_findAux_rootD
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: rw [parentD_findAux]
state_before: self : UnionFind
x : Fin self.size
⊢ parentD (self.findAux x).s (self.rootD ↑x) = self.rootD ↑x
state_after: self : UnionFind
x : Fin self.size
⊢ (if self.rootD ↑x = ↑x then self.rootD ↑x
    else parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x)) =
    self.rootD ↑x

tactic: split <;> [rfl; rename_i h]
state_before: self : UnionFind
x : Fin self.size
⊢ (if self.rootD ↑x = ↑x then self.rootD ↑x
    else parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x)) =
    self.rootD ↑x
state_after: case isFalse
self : UnionFind
x : Fin self.size
h : ¬self.rootD ↑x = ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x) = self.rootD ↑x

tactic: rw [rootD_eq_self, parent, parentD_eq] at h
state_before: case isFalse
self : UnionFind
x : Fin self.size
h : ¬self.rootD ↑x = ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x) = self.rootD ↑x
state_after: case isFalse
self : UnionFind
x : Fin self.size
h : ¬(self.arr.get x).parent = ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x) = self.rootD ↑x

tactic: have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›)
state_before: case isFalse
self : UnionFind
x : Fin self.size
h : ¬(self.arr.get x).parent = ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x) = self.rootD ↑x
state_after: case isFalse
self : UnionFind
x : Fin self.size
h : ¬(self.arr.get x).parent = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x) = self.rootD ↑x

tactic: rw [← rootD_parent, parent, parentD_eq]
state_before: case isFalse
self : UnionFind
x : Fin self.size
h : ¬(self.arr.get x).parent = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD ↑x) = self.rootD ↑x
state_after: case isFalse
self : UnionFind
x : Fin self.size
h : ¬(self.arr.get x).parent = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD (self.arr.get x).parent) =
    self.rootD (self.arr.get x).parent

tactic: exact parentD_findAux_rootD (x := ⟨_, self.parent'_lt x⟩)
state_before: case isFalse
self : UnionFind
x : Fin self.size
h : ¬(self.arr.get x).parent = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s (self.rootD (self.arr.get x).parent) =
    self.rootD (self.arr.get x).parent
state_after: no goals
Theorem: LinearPMap.mem_graph_iff
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: cases x
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E × F
⊢ x ∈ f.graph ↔ ∃ y, ↑y = x.1 ∧ ↑f y = x.2
state_after: case mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
fst✝ : E
snd✝ : F
⊢ (fst✝, snd✝) ∈ f.graph ↔ ∃ y, ↑y = (fst✝, snd✝).1 ∧ ↑f y = (fst✝, snd✝).2

tactic: simp_rw [mem_graph_iff', Prod.mk.inj_iff]
state_before: case mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
fst✝ : E
snd✝ : F
⊢ (fst✝, snd✝) ∈ f.graph ↔ ∃ y, ↑y = (fst✝, snd✝).1 ∧ ↑f y = (fst✝, snd✝).2
state_after: no goals
Theorem: CategoryTheory.ShortComplex.kernel_ι_comp_cokernel_π_comp_cokernelToAbelianCoimage
File: Mathlib/Algebra/Homology/ShortComplex/Abelian.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
S : ShortComplex C
⊢ (kernel.ι S.g ≫ cokernel.π S.f) ≫ S.cokernelToAbelianCoimage = 0
state_after: no goals
Theorem: HurwitzKernelBounds.f_int_ofNat
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

tactic: rw [f_int, f_nat, Int.ofNat_eq_coe, Int.cast_natCast, abs_of_nonneg (by positivity)]
state_before: k : ℕ
a : ℝ
ha : 0 ≤ a
t : ℝ
n : ℕ
⊢ f_int k a t (Int.ofNat n) = f_nat k a t n
state_after: no goals

tactic: positivity
state_before: k : ℕ
a : ℝ
ha : 0 ≤ a
t : ℝ
n : ℕ
⊢ 0 ≤ ↑n + a
state_after: no goals
Theorem: MeasureTheory.integrableOn_singleton_iff
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: have : f =ᵐ[μ.restrict {x}] fun _ => f x := by
  filter_upwards [ae_restrict_mem (measurableSet_singleton x)] with _ ha
  simp only [mem_singleton_iff.1 ha]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
⊢ IntegrableOn f {x} μ ↔ f x = 0 ∨ μ {x} < ⊤
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
this : f =ᶠ[ae (μ.restrict {x})] fun x_1 => f x
⊢ IntegrableOn f {x} μ ↔ f x = 0 ∨ μ {x} < ⊤

tactic: rw [IntegrableOn, integrable_congr this, integrable_const_iff]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
this : f =ᶠ[ae (μ.restrict {x})] fun x_1 => f x
⊢ IntegrableOn f {x} μ ↔ f x = 0 ∨ μ {x} < ⊤
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
this : f =ᶠ[ae (μ.restrict {x})] fun x_1 => f x
⊢ f x = 0 ∨ (μ.restrict {x}) univ < ⊤ ↔ f x = 0 ∨ μ {x} < ⊤

tactic: simp
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
this : f =ᶠ[ae (μ.restrict {x})] fun x_1 => f x
⊢ f x = 0 ∨ (μ.restrict {x}) univ < ⊤ ↔ f x = 0 ∨ μ {x} < ⊤
state_after: no goals

tactic: filter_upwards [ae_restrict_mem (measurableSet_singleton x)] with _ ha
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
⊢ f =ᶠ[ae (μ.restrict {x})] fun x_1 => f x
state_after: case h
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
a✝ : α
ha : a✝ ∈ {x}
⊢ f a✝ = f x

tactic: simp only [mem_singleton_iff.1 ha]
state_before: case h
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
x : α
inst✝ : MeasurableSingletonClass α
a✝ : α
ha : a✝ ∈ {x}
⊢ f a✝ = f x
state_after: no goals
Theorem: inseparable_pi
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [Inseparable, nhds_pi, funext_iff, pi_inj]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f✝ g✝ : X → Y
f g : (i : ι) → π i
⊢ (f ~ᵢ g) ↔ ∀ (i : ι), f i ~ᵢ g i
state_after: no goals
Theorem: exterior_subset_iff_isOpen
File: Mathlib/Topology/AlexandrovDiscrete.lean

tactic: simp only [exterior_eq_iff_isOpen.symm, Subset.antisymm_iff, subset_exterior, and_true]
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ s ↔ IsOpen s
state_after: no goals
Theorem: MeasureTheory.ProgMeasurable.finset_prod
File: Mathlib/Probability/Process/Adapted.lean

tactic: convert ProgMeasurable.finset_prod' h using 1
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁴ : TopologicalSpace β
inst✝³ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝² : MeasurableSpace ι
γ : Type u_4
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
U : γ → ι → Ω → β
s : Finset γ
h : ∀ c ∈ s, ProgMeasurable f (U c)
⊢ ProgMeasurable f fun i a => ∏ c ∈ s, U c i a
state_after: case h.e'_9
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁴ : TopologicalSpace β
inst✝³ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝² : MeasurableSpace ι
γ : Type u_4
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
U : γ → ι → Ω → β
s : Finset γ
h : ∀ c ∈ s, ProgMeasurable f (U c)
⊢ (fun i a => ∏ c ∈ s, U c i a) = ∏ c ∈ s, U c

tactic: ext (i a)
state_before: case h.e'_9
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁴ : TopologicalSpace β
inst✝³ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝² : MeasurableSpace ι
γ : Type u_4
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
U : γ → ι → Ω → β
s : Finset γ
h : ∀ c ∈ s, ProgMeasurable f (U c)
⊢ (fun i a => ∏ c ∈ s, U c i a) = ∏ c ∈ s, U c
state_after: case h.e'_9.h.h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁴ : TopologicalSpace β
inst✝³ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝² : MeasurableSpace ι
γ : Type u_4
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
U : γ → ι → Ω → β
s : Finset γ
h : ∀ c ∈ s, ProgMeasurable f (U c)
i : ι
a : Ω
⊢ ∏ c ∈ s, U c i a = (∏ c ∈ s, U c) i a

tactic: simp only [Finset.prod_apply]
state_before: case h.e'_9.h.h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁴ : TopologicalSpace β
inst✝³ : Preorder ι
u v : ι → Ω → β
f : Filtration ι m
inst✝² : MeasurableSpace ι
γ : Type u_4
inst✝¹ : CommMonoid β
inst✝ : ContinuousMul β
U : γ → ι → Ω → β
s : Finset γ
h : ∀ c ∈ s, ProgMeasurable f (U c)
i : ι
a : Ω
⊢ ∏ c ∈ s, U c i a = (∏ c ∈ s, U c) i a
state_after: no goals
Theorem: HomogeneousIdeal.ext'
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: ext
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
⊢ I = J
state_after: case h.h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
x✝ : A
⊢ x✝ ∈ I.toIdeal ↔ x✝ ∈ J.toIdeal

tactic: rw [I.isHomogeneous.mem_iff, J.isHomogeneous.mem_iff]
state_before: case h.h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
x✝ : A
⊢ x✝ ∈ I.toIdeal ↔ x✝ ∈ J.toIdeal
state_after: case h.h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
x✝ : A
⊢ (∀ (i : ι), ↑(((decompose 𝒜) x✝) i) ∈ I.toIdeal) ↔ ∀ (i : ι), ↑(((decompose 𝒜) x✝) i) ∈ J.toIdeal

tactic: apply forall_congr'
state_before: case h.h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
x✝ : A
⊢ (∀ (i : ι), ↑(((decompose 𝒜) x✝) i) ∈ I.toIdeal) ↔ ∀ (i : ι), ↑(((decompose 𝒜) x✝) i) ∈ J.toIdeal
state_after: case h.h.h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
x✝ : A
⊢ ∀ (a : ι), ↑(((decompose 𝒜) x✝) a) ∈ I.toIdeal ↔ ↑(((decompose 𝒜) x✝) a) ∈ J.toIdeal

tactic: exact fun i ↦ h i _ (decompose 𝒜 _ i).2
state_before: case h.h.h
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I J : HomogeneousIdeal 𝒜
h : ∀ (i : ι), ∀ x ∈ 𝒜 i, x ∈ I ↔ x ∈ J
x✝ : A
⊢ ∀ (a : ι), ↑(((decompose 𝒜) x✝) a) ∈ I.toIdeal ↔ ↑(((decompose 𝒜) x✝) a) ∈ J.toIdeal
state_after: no goals
Theorem: Primrec₂.uncurry
File: Mathlib/Computability/Primrec.lean

tactic: rw [show Function.uncurry f = fun p : α × β => f p.1 p.2 from funext fun ⟨a, b⟩ => rfl]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
⊢ Primrec (Function.uncurry f) ↔ Primrec₂ f
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec fun p => f p.1 p.2) ↔ Primrec₂ f

tactic: rfl
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec fun p => f p.1 p.2) ↔ Primrec₂ f
state_after: no goals
Theorem: CategoryTheory.Functor.preimageIso_mapIso
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: ext
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
X✝ Y✝ : C
F : C ⥤ D
inst✝¹ : F.Full
inst✝ : F.Faithful
X Y Z : C
f : X ≅ Y
⊢ F.preimageIso (F.mapIso f) = f
state_after: case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
X✝ Y✝ : C
F : C ⥤ D
inst✝¹ : F.Full
inst✝ : F.Faithful
X Y Z : C
f : X ≅ Y
⊢ (F.preimageIso (F.mapIso f)).hom = f.hom

tactic: simp
state_before: case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
X✝ Y✝ : C
F : C ⥤ D
inst✝¹ : F.Full
inst✝ : F.Faithful
X Y Z : C
f : X ≅ Y
⊢ (F.preimageIso (F.mapIso f)).hom = f.hom
state_after: no goals
Theorem: orderOf_dvd_of_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: obtain ⟨k, rfl⟩ := Subgroup.mem_zpowers_iff.mp h
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i : ℤ
h : y ∈ zpowers x
⊢ orderOf y ∣ orderOf x
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x : G
i k : ℤ
h : x ^ k ∈ zpowers x
⊢ orderOf (x ^ k) ∣ orderOf x

tactic: rw [orderOf_dvd_iff_pow_eq_one]
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x : G
i k : ℤ
h : x ^ k ∈ zpowers x
⊢ orderOf (x ^ k) ∣ orderOf x
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x : G
i k : ℤ
h : x ^ k ∈ zpowers x
⊢ (x ^ k) ^ orderOf x = 1

tactic: exact zpow_pow_orderOf
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x : G
i k : ℤ
h : x ^ k ∈ zpowers x
⊢ (x ^ k) ^ orderOf x = 1
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.lintegral_congr
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [hx]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
h : ↑f =ᶠ[ae μ] ↑g
y : ℝ≥0∞
x : α
hx : ↑f x = ↑g x
⊢ x ∈ ↑f ⁻¹' {y} ↔ x ∈ ↑g ⁻¹' {y}
state_after: no goals
Theorem: CategoryTheory.Functor.FullyFaithful.hasShift.map_zero_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: simp [zero]
state_before: C : Type u
A : Type u_1
inst✝³ : Category.{v, u} C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : AddMonoid A
inst✝ : HasShift D A
F : C ⥤ D
hF : F.FullyFaithful
s : A → C ⥤ C
i : (i : A) → s i ⋙ F ≅ F ⋙ shiftFunctor D i
X : C
⊢ F.map ((zero hF s i).inv.app X) = (shiftFunctorZero D A).inv.app (F.obj X) ≫ (i 0).inv.app X
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.negDblY_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [negDblY, dblX, toAffine_slope_of_eq hP hQ hPz hQz hx hy, dblZ, ← (X_eq_iff hPz hQz).mp hx,
  toAffine_negAddY_of_eq hPz <| sub_ne_zero_of_ne <| Y_ne_negY_of_Y_ne' hP hQ hx hy]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3
⊢ W.negDblY P / W.dblZ P ^ 3 =
    W.toAffine.negAddY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
      (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3))
state_after: no goals
Theorem: measurableSet_inl_image
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simp [measurableSet_sum_iff, Sum.inl_injective.preimage_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
⊢ MeasurableSet (Sum.inl '' s) ↔ MeasurableSet s
state_after: no goals
Theorem: FirstOrder.Language.LHom.map_constants_comp_sumInl
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: ext <;> rfl
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
β : Type u_1
f : α → β
⊢ (L.lhomWithConstantsMap f).comp LHom.sumInl = L.lhomWithConstants β
state_after: no goals
Theorem: ProbabilityTheory.kernel.rnDeriv_eq_top_iff'
File: Mathlib/Probability/Kernel/RadonNikodym.lean

tactic: rw [rnDeriv_eq_top_iff]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
x : γ
⊢ rnDeriv κ η a x = ⊤ ↔ x ∈ mutuallySingularSetSlice κ η a
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
x : γ
⊢ (a, x) ∈ mutuallySingularSet κ η ↔ x ∈ mutuallySingularSetSlice κ η a

tactic: rfl
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
x : γ
⊢ (a, x) ∈ mutuallySingularSet κ η ↔ x ∈ mutuallySingularSetSlice κ η a
state_after: no goals
Theorem: ContinuousMap.tendsto_iff_tendstoLocallyUniformly
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: refine ⟨fun h V hV x ↦ ?_, tendsto_of_tendstoLocallyUniformly⟩
state_before: α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
⊢ Tendsto F p (𝓝 f) ↔ TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
state_after: α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
h : Tendsto F p (𝓝 f)
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
⊢ ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, (fun i a => (F i) a) n y) ∈ V

tactic: rw [tendsto_iff_forall_compact_tendstoUniformlyOn] at h
state_before: α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
h : Tendsto F p (𝓝 f)
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
⊢ ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, (fun i a => (F i) a) n y) ∈ V
state_after: α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
⊢ ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, (fun i a => (F i) a) n y) ∈ V

tactic: obtain ⟨n, hn₁, hn₂⟩ := exists_compact_mem_nhds x
state_before: α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
⊢ ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, (fun i a => (F i) a) n y) ∈ V
state_after: case intro.intro
α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
n : Set α
hn₁ : IsCompact n
hn₂ : n ∈ 𝓝 x
⊢ ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, (fun i a => (F i) a) n y) ∈ V

tactic: exact ⟨n, hn₂, h n hn₁ V hV⟩
state_before: case intro.intro
α : Type u₁
β : Type u₂
inst✝² : TopologicalSpace α
inst✝¹ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
inst✝ : WeaklyLocallyCompactSpace α
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
n : Set α
hn₁ : IsCompact n
hn₂ : n ∈ 𝓝 x
⊢ ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, (fun i a => (F i) a) n y) ∈ V
state_after: no goals
Theorem: Set.inv_range
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_inv]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s t : Set α
a : α
ι : Sort u_5
f : ι → α
⊢ (range f)⁻¹ = range fun i => (f i)⁻¹
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s t : Set α
a : α
ι : Sort u_5
f : ι → α
⊢ Inv.inv '' range f = range fun i => (f i)⁻¹

tactic: exact (range_comp _ _).symm
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s t : Set α
a : α
ι : Sort u_5
f : ι → α
⊢ Inv.inv '' range f = range fun i => (f i)⁻¹
state_after: no goals
Theorem: MeasureTheory.LpAddConst_of_one_le
File: Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean

tactic: rw [LpAddConst, if_neg]
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p✝ : ℝ≥0∞
q : ℝ
μ : Measure α
f g : α → E
p : ℝ≥0∞
hp : 1 ≤ p
⊢ LpAddConst p = 1
state_after: case hnc
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p✝ : ℝ≥0∞
q : ℝ
μ : Measure α
f g : α → E
p : ℝ≥0∞
hp : 1 ≤ p
⊢ p ∉ Set.Ioo 0 1

tactic: intro h
state_before: case hnc
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p✝ : ℝ≥0∞
q : ℝ
μ : Measure α
f g : α → E
p : ℝ≥0∞
hp : 1 ≤ p
⊢ p ∉ Set.Ioo 0 1
state_after: case hnc
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p✝ : ℝ≥0∞
q : ℝ
μ : Measure α
f g : α → E
p : ℝ≥0∞
hp : 1 ≤ p
h : p ∈ Set.Ioo 0 1
⊢ False

tactic: exact lt_irrefl _ (h.2.trans_le hp)
state_before: case hnc
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p✝ : ℝ≥0∞
q : ℝ
μ : Measure α
f g : α → E
p : ℝ≥0∞
hp : 1 ≤ p
h : p ∈ Set.Ioo 0 1
⊢ False
state_after: no goals