1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.map_add_right_Icc
File: Mathlib/Algebra/Order/Interval/Finset.lean

tactic: rw [← coe_inj, coe_map, coe_Icc, coe_Icc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Icc a b) = Icc (a + c) (b + c)
state_after: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Icc a b = Set.Icc (a + c) (b + c)

tactic: exact Set.image_add_const_Icc _ _ _
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Icc a b = Set.Icc (a + c) (b + c)
state_after: no goals
Theorem: ProbabilityTheory.IndepSets_iff
File: Mathlib/Probability/Independence/Basic.lean

tactic: simp only [IndepSets, kernel.IndepSets, ae_dirac_eq, Filter.eventually_pure, kernel.const_apply]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
s1 s2 : Set (Set Ω)
μ : Measure Ω
⊢ IndepSets s1 s2 μ ↔ ∀ (t1 t2 : Set Ω), t1 ∈ s1 → t2 ∈ s2 → μ (t1 ∩ t2) = μ t1 * μ t2
state_after: no goals
Theorem: ExistsContDiffBumpBase.w_def
File: Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean

tactic: ext1 x
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
⊢ w D = fun x => ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)
state_after: case h
E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ w D x = ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)

tactic: rfl
state_before: case h
E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ w D x = ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)
state_after: no goals
Theorem: Filter.tendsto_div_const_atTop_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [div_eq_mul_inv, tendsto_mul_const_atTop_of_neg, hr]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x / r) l atTop ↔ Tendsto f l atBot
state_after: no goals
Theorem: Set.Iic_iInf
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [mem_Iic, le_iInf_iff, mem_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : CompleteLattice α
f : ι → α
x✝ : α
⊢ x✝ ∈ Iic (⨅ i, f i) ↔ x✝ ∈ ⋂ i, Iic (f i)
state_after: no goals
Theorem: WittVector.verschiebung_frobenius_comm
File: Mathlib/RingTheory/WittVector/Identities.lean

tactic: rw [verschiebung_frobenius, frobenius_verschiebung]
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
x : 𝕎 R
⊢ verschiebung (frobenius x) = frobenius (verschiebung x)
state_after: no goals
Theorem: Matrix.SpecialLinearGroup.isCoprime_row
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simp_rw [det_coe A ▸ det_fin_two A.1]
state_before: case refine_2
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
A : SL(2, R)
i : Fin 2
⊢ -↑A 0 1 * ↑A 1 0 + ↑A 0 0 * ↑A 1 1 = 1
state_after: case refine_2
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
A : SL(2, R)
i : Fin 2
⊢ -↑A 0 1 * ↑A 1 0 + ↑A 0 0 * ↑A 1 1 = ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0

tactic: ring
state_before: case refine_2
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
A : SL(2, R)
i : Fin 2
⊢ -↑A 0 1 * ↑A 1 0 + ↑A 0 0 * ↑A 1 1 = ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0
state_after: no goals
Theorem: AddConstMapClass.map_sub_int'
File: Mathlib/Algebra/AddConstMap/Basic.lean

tactic: rw [← map_sub_zsmul, zsmul_one]
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddGroupWithOne G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H 1 b
f : F
x : G
n : ℤ
⊢ f (x - ↑n) = f x - n • b
state_after: no goals
Theorem: SimpleGraph.edgeFinset_bot
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

tactic: simp [edgeFinset]
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝² : Fintype ↑G.edgeSet
inst✝¹ : Fintype ↑G₁.edgeSet
inst✝ : Fintype ↑G₂.edgeSet
⊢ ⊥.edgeFinset = ∅
state_after: no goals
Theorem: Cardinal.mk_eq_two_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp only [← @Nat.cast_two Cardinal, mk_eq_nat_iff_finset, Finset.card_eq_two]
state_before: α β : Type u
c : Cardinal.{?u.235611}
⊢ #α = 2 ↔ ∃ x y, x ≠ y ∧ {x, y} = univ
state_after: α β : Type u
c : Cardinal.{?u.235611}
⊢ (∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}) ↔ ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: constructor
state_before: α β : Type u
c : Cardinal.{?u.235611}
⊢ (∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}) ↔ ∃ x y, x ≠ y ∧ {x, y} = univ
state_after: case mp
α β : Type u
c : Cardinal.{?u.235611}
⊢ (∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}) → ∃ x y, x ≠ y ∧ {x, y} = univ

case mpr
α β : Type u
c : Cardinal.{?u.235611}
⊢ (∃ x y, x ≠ y ∧ {x, y} = univ) → ∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}

tactic: rintro ⟨t, ht, x, y, hne, rfl⟩
state_before: case mp
α β : Type u
c : Cardinal.{?u.235611}
⊢ (∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}) → ∃ x y, x ≠ y ∧ {x, y} = univ
state_after: case mp.intro.intro.intro.intro.intro
α β : Type u
c : Cardinal.{?u.235611}
x y : α
hne : x ≠ y
ht : ↑{x, y} = univ
⊢ ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: exact ⟨x, y, hne, by simpa using ht⟩
state_before: case mp.intro.intro.intro.intro.intro
α β : Type u
c : Cardinal.{?u.235611}
x y : α
hne : x ≠ y
ht : ↑{x, y} = univ
⊢ ∃ x y, x ≠ y ∧ {x, y} = univ
state_after: no goals

tactic: simpa using ht
state_before: α β : Type u
c : Cardinal.{?u.235611}
x y : α
hne : x ≠ y
ht : ↑{x, y} = univ
⊢ {x, y} = univ
state_after: no goals

tactic: rintro ⟨x, y, hne, h⟩
state_before: case mpr
α β : Type u
c : Cardinal.{?u.235611}
⊢ (∃ x y, x ≠ y ∧ {x, y} = univ) → ∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}
state_after: case mpr.intro.intro.intro
α β : Type u
c : Cardinal.{?u.235611}
x y : α
hne : x ≠ y
h : {x, y} = univ
⊢ ∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}

tactic: exact ⟨{x, y}, by simpa using h, x, y, hne, rfl⟩
state_before: case mpr.intro.intro.intro
α β : Type u
c : Cardinal.{?u.235611}
x y : α
hne : x ≠ y
h : {x, y} = univ
⊢ ∃ t, ↑t = univ ∧ ∃ x y, x ≠ y ∧ t = {x, y}
state_after: no goals

tactic: simpa using h
state_before: α β : Type u
c : Cardinal.{?u.235611}
x y : α
hne : x ≠ y
h : {x, y} = univ
⊢ ↑{x, y} = univ
state_after: no goals
Theorem: CategoryTheory.Adjunction.rightAdjointUniq_hom_app_counit
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

tactic: simp [rightAdjointUniq]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ F.map ((adj1.rightAdjointUniq adj2).hom.app x) ≫ adj2.counit.app x = adj1.counit.app x
state_after: no goals
Theorem: Relation.acc_of_singleton
File: Mathlib/Logic/Hydra.lean

tactic: induction s using Multiset.induction with
| empty => exact Acc.intro 0 fun s h ↦ (not_cutExpand_zero s h).elim
| cons a s ihs =>
  rw [← s.singleton_add a]
  rw [forall_mem_cons] at hs
  exact (hs.1.prod_gameAdd <| ihs fun a ha ↦ hs.2 a ha).of_fibration _ (cutExpand_fibration r)
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
s : Multiset α
hs : ∀ a ∈ s, Acc (CutExpand r) {a}
⊢ Acc (CutExpand r) s
state_after: no goals

tactic: exact Acc.intro 0 fun s h ↦ (not_cutExpand_zero s h).elim
state_before: case empty
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
hs : ∀ a ∈ 0, Acc (CutExpand r) {a}
⊢ Acc (CutExpand r) 0
state_after: no goals

tactic: rw [← s.singleton_add a]
state_before: case cons
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
s : Multiset α
ihs : (∀ a ∈ s, Acc (CutExpand r) {a}) → Acc (CutExpand r) s
hs : ∀ a_1 ∈ a ::ₘ s, Acc (CutExpand r) {a_1}
⊢ Acc (CutExpand r) (a ::ₘ s)
state_after: case cons
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
s : Multiset α
ihs : (∀ a ∈ s, Acc (CutExpand r) {a}) → Acc (CutExpand r) s
hs : ∀ a_1 ∈ a ::ₘ s, Acc (CutExpand r) {a_1}
⊢ Acc (CutExpand r) ({a} + s)

tactic: rw [forall_mem_cons] at hs
state_before: case cons
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
s : Multiset α
ihs : (∀ a ∈ s, Acc (CutExpand r) {a}) → Acc (CutExpand r) s
hs : ∀ a_1 ∈ a ::ₘ s, Acc (CutExpand r) {a_1}
⊢ Acc (CutExpand r) ({a} + s)
state_after: case cons
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
s : Multiset α
ihs : (∀ a ∈ s, Acc (CutExpand r) {a}) → Acc (CutExpand r) s
hs : Acc (CutExpand r) {a} ∧ ∀ x ∈ s, Acc (CutExpand r) {x}
⊢ Acc (CutExpand r) ({a} + s)

tactic: exact (hs.1.prod_gameAdd <| ihs fun a ha ↦ hs.2 a ha).of_fibration _ (cutExpand_fibration r)
state_before: case cons
α : Type u_1
r : α → α → Prop
inst✝ : IsIrrefl α r
a : α
s : Multiset α
ihs : (∀ a ∈ s, Acc (CutExpand r) {a}) → Acc (CutExpand r) s
hs : Acc (CutExpand r) {a} ∧ ∀ x ∈ s, Acc (CutExpand r) {x}
⊢ Acc (CutExpand r) ({a} + s)
state_after: no goals
Theorem: CategoryTheory.Quotient.natTransLift_id
File: Mathlib/CategoryTheory/Quotient.lean

tactic: aesop_cat
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F : Quotient r ⥤ D
⊢ natTransLift r (𝟙 (functor r ⋙ F)) = 𝟙 F
state_after: no goals
Theorem: ProbabilityTheory.setIntegral_compProd_univ_left
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

tactic: simp_rw [setIntegral_compProd MeasurableSet.univ ht hf, Measure.restrict_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁶ : NormedAddCommGroup E
κ : ↥(kernel α β)
inst✝⁵ : IsSFiniteKernel κ
η : ↥(kernel (α × β) γ)
inst✝⁴ : IsSFiniteKernel η
a : α
inst✝³ : NormedSpace ℝ E
E' : Type u_5
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : β × γ → E
t : Set γ
ht : MeasurableSet t
hf : IntegrableOn f (univ ×ˢ t) ((κ ⊗ₖ η) a)
⊢ ∫ (z : β × γ) in univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ (x : β), ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
state_after: no goals
Theorem: OrthonormalBasis.repr_injective
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: cases f
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
f g : OrthonormalBasis ι 𝕜 E
h : f.repr = g.repr
⊢ f = g
state_after: case ofRepr
ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
g : OrthonormalBasis ι 𝕜 E
repr✝ : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
h : { repr := repr✝ }.repr = g.repr
⊢ { repr := repr✝ } = g

tactic: cases g
state_before: case ofRepr
ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
g : OrthonormalBasis ι 𝕜 E
repr✝ : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
h : { repr := repr✝ }.repr = g.repr
⊢ { repr := repr✝ } = g
state_after: case ofRepr.ofRepr
ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
repr✝¹ repr✝ : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
h : { repr := repr✝¹ }.repr = { repr := repr✝ }.repr
⊢ { repr := repr✝¹ } = { repr := repr✝ }

tactic: congr
state_before: case ofRepr.ofRepr
ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
repr✝¹ repr✝ : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
h : { repr := repr✝¹ }.repr = { repr := repr✝ }.repr
⊢ { repr := repr✝¹ } = { repr := repr✝ }
state_after: no goals
Theorem: String.Iterator.ValidFor.toEnd'
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp only [Iterator.toEnd]
state_before: it : Iterator
⊢ ValidFor it.s.data.reverse [] it.toEnd
state_after: it : Iterator
⊢ ValidFor it.s.data.reverse [] { s := it.s, i := it.s.endPos }

tactic: exact .of_eq _ (by simp [List.reverseAux_eq]) (by simp [endPos, utf8ByteSize])
state_before: it : Iterator
⊢ ValidFor it.s.data.reverse [] { s := it.s, i := it.s.endPos }
state_after: no goals

tactic: simp [List.reverseAux_eq]
state_before: it : Iterator
⊢ { s := it.s, i := it.s.endPos }.s.data = it.s.data.reverse.reverseAux []
state_after: no goals

tactic: simp [endPos, utf8ByteSize]
state_before: it : Iterator
⊢ { s := it.s, i := it.s.endPos }.i.byteIdx = utf8Len it.s.data.reverse
state_after: no goals
Theorem: Multiset.powersetCard_zero_left
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetCard_coe']
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ powersetCard 0 ⟦l⟧ = {0}
state_after: no goals
Theorem: QuasiErgodic.ae_eq_const_of_ae_eq_comp_of_ae_range₀
File: Mathlib/Dynamics/Ergodic/Function.lean

tactic: refine exists_eventuallyEq_const_of_eventually_mem_of_forall_separating MeasurableSet hs ?_
state_before: α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
⊢ ∃ c, g =ᶠ[ae μ] const α c
state_after: α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
⊢ ∀ (U : Set X), MeasurableSet U → (∀ᵐ (x : α) ∂μ, g x ∈ U) ∨ ∀ᵐ (x : α) ∂μ, g x ∉ U

tactic: refine fun U hU ↦ h.ae_mem_or_ae_nmem₀ (s := g ⁻¹' U) (hgm hU) ?_b
state_before: α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
⊢ ∀ (U : Set X), MeasurableSet U → (∀ᵐ (x : α) ∂μ, g x ∈ U) ∨ ∀ᵐ (x : α) ∂μ, g x ∉ U
state_after: case _b
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
U : Set X
hU : MeasurableSet U
⊢ f ⁻¹' (g ⁻¹' U) =ᶠ[ae μ] g ⁻¹' U

tactic: refine (hg_eq.mono fun x hx ↦ ?_).set_eq
state_before: case _b
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
U : Set X
hU : MeasurableSet U
⊢ f ⁻¹' (g ⁻¹' U) =ᶠ[ae μ] g ⁻¹' U
state_after: case _b
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
U : Set X
hU : MeasurableSet U
x : α
hx : (g ∘ f) x = g x
⊢ x ∈ f ⁻¹' (g ⁻¹' U) ↔ x ∈ g ⁻¹' U

tactic: rw [← preimage_comp, mem_preimage, mem_preimage, hx]
state_before: case _b
α : Type u_1
X : Type u_2
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Nonempty X
inst✝¹ : MeasurableSpace X
s : Set X
inst✝ : MeasurableSpace.CountablySeparated ↑s
f : α → α
g : α → X
h : QuasiErgodic f μ
hs : ∀ᵐ (x : α) ∂μ, g x ∈ s
hgm : NullMeasurable g μ
hg_eq : g ∘ f =ᶠ[ae μ] g
U : Set X
hU : MeasurableSet U
x : α
hx : (g ∘ f) x = g x
⊢ x ∈ f ⁻¹' (g ⁻¹' U) ↔ x ∈ g ⁻¹' U
state_after: no goals
Theorem: Real.arcsin_sin'
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [sin_arcsin (neg_one_le_sin _) (sin_le_one _)]
state_before: x✝ y x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ sin (arcsin (sin x)) = sin x
state_after: no goals
Theorem: Hyperreal.infinitesimal_def
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simp [Infinitesimal, IsSt]
state_before: x : ℝ*
⊢ x.Infinitesimal ↔ ∀ (r : ℝ), 0 < r → -↑r < x ∧ x < ↑r
state_after: no goals
Theorem: Set.biUnion_of_singleton
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
⊢ ∀ (x : α), x ∈ ⋃ x ∈ s, {x} ↔ x ∈ s
state_after: no goals
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.ofRestrict_invApp
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: delta invApp
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ invApp (X.ofRestrict h) U = 𝟙 ((X.restrict h).presheaf.obj { unop := U })
state_after: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) ≫
      inv ((X.ofRestrict h).c.app { unop := (opensFunctor (X.ofRestrict h)).obj U }) =
    𝟙 ((X.restrict h).presheaf.obj { unop := U })

tactic: rw [IsIso.comp_inv_eq, Category.id_comp]
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) ≫
      inv ((X.ofRestrict h).c.app { unop := (opensFunctor (X.ofRestrict h)).obj U }) =
    𝟙 ((X.restrict h).presheaf.obj { unop := U })
state_after: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) = (X.ofRestrict h).c.app { unop := (opensFunctor (X.ofRestrict h)).obj U }

tactic: change X.presheaf.map _ = X.presheaf.map _
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) = (X.ofRestrict h).c.app { unop := (opensFunctor (X.ofRestrict h)).obj U }
state_after: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ X.presheaf.map (⋯.functor.op.map (eqToHom ⋯)) =
    X.presheaf.map (⋯.adjunction.counit.app { unop := (opensFunctor (X.ofRestrict h)).obj U }.unop).op

tactic: congr 1
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ X.presheaf.map (⋯.functor.op.map (eqToHom ⋯)) =
    X.presheaf.map (⋯.adjunction.counit.app { unop := (opensFunctor (X.ofRestrict h)).obj U }.unop).op
state_after: no goals
Theorem: Basis.toDual_apply_right
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← b.toDual_total_right, b.total_repr]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i : ι
m : M
⊢ (b.toDual (b i)) m = (b.repr m) i
state_after: no goals
Theorem: SimpleGraph.Walk.length_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ _ ih => simp [ih, add_comm, add_left_comm, add_assoc]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
q : G.Walk v w
⊢ (p.append q).length = p.length + q.length
state_after: no goals

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ : V
q : G.Walk u✝ w
⊢ (nil.append q).length = nil.length + q.length
state_after: no goals

tactic: simp [ih, add_comm, add_left_comm, add_assoc]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih : ∀ (q : G.Walk w✝ w), (p✝.append q).length = p✝.length + q.length
q : G.Walk w✝ w
⊢ ((cons h✝ p✝).append q).length = (cons h✝ p✝).length + q.length
state_after: no goals
Theorem: List.formPerm_apply_getElem_length
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rw [getElem_cons_length, formPerm_apply_getLast]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ (x :: xs).formPerm (x :: xs)[xs.length] = x
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ xs.length = xs.length

tactic: rfl
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ xs.length = xs.length
state_after: no goals