1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.union_ae_eq_right_iff_ae_subset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [union_comm, union_ae_eq_left_iff_ae_subset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s ∪ t =ᶠ[ae μ] t ↔ s ≤ᶠ[ae μ] t
state_after: no goals
Theorem: Behrend.bound_aux
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: convert bound_aux' n d using 1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n ≤ ↑(rothNumberNat ((2 * d - 1) ^ n))
state_after: case h.e'_3
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n = ↑(d ^ n) / ↑(n * d ^ 2)

tactic: rw [cast_mul, cast_pow, mul_comm, ← div_div, pow_sub₀ _ _ hn, ← div_eq_mul_inv, cast_pow]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n = ↑(d ^ n) / ↑(n * d ^ 2)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ≠ 0

tactic: rwa [cast_ne_zero]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ≠ 0
state_after: no goals
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.app_inv_app'
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: erw [← Category.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
⊢ f.c.app { unop := U } ≫ invApp f ((Opens.map f.base).obj U) = Y.presheaf.map (eqToHom ⋯).op
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
⊢ (f.c.app { unop := U } ≫ X.presheaf.map (eqToHom ⋯)) ≫
      inv (f.c.app { unop := (opensFunctor f).obj ((Opens.map f.base).obj U) }) =
    Y.presheaf.map (eqToHom ⋯).op

tactic: rw [IsIso.comp_inv_eq, f.c.naturality]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
⊢ (f.c.app { unop := U } ≫ X.presheaf.map (eqToHom ⋯)) ≫
      inv (f.c.app { unop := (opensFunctor f).obj ((Opens.map f.base).obj U) }) =
    Y.presheaf.map (eqToHom ⋯).op
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
⊢ f.c.app { unop := U } ≫ X.presheaf.map (eqToHom ⋯) = f.c.app { unop := U } ≫ (f.base _* X.presheaf).map (eqToHom ⋯).op

tactic: congr
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑Y
hU : ↑U ⊆ Set.range ⇑f.base
⊢ f.c.app { unop := U } ≫ X.presheaf.map (eqToHom ⋯) = f.c.app { unop := U } ≫ (f.base _* X.presheaf).map (eqToHom ⋯).op
state_after: no goals
Theorem: MeasureTheory.Measure.nnreal_smul_coe_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
_m : MeasurableSpace α
c : ℝ≥0
μ : Measure α
s : Set α
⊢ c • μ s = ↑c * μ s
state_after: no goals
Theorem: infClosed_range
File: Mathlib/Order/SupClosed.lean

tactic: simpa using infClosed_univ.image f
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : SemilatticeInf α
inst✝² : SemilatticeInf β
ι : Sort u_4
S : Set (Set α)
f✝ : ι → Set α
s t : Set α
a : α
inst✝¹ : FunLike F α β
inst✝ : InfHomClass F α β
f : F
⊢ InfClosed (range ⇑f)
state_after: no goals
Theorem: PosNum.size_eq_natSize
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [size, succ_to_nat, natSize, size_eq_natSize n]
state_before: α : Type u_1
n : PosNum
⊢ ↑n.bit0.size = n.bit0.natSize
state_after: no goals

tactic: rw [size, succ_to_nat, natSize, size_eq_natSize n]
state_before: α : Type u_1
n : PosNum
⊢ ↑n.bit1.size = n.bit1.natSize
state_after: no goals
Theorem: Cardinal.cantorFunctionAux_zero
File: Mathlib/Data/Real/Cardinality.lean

tactic: cases h : f 0 <;> simp [h]
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
⊢ cantorFunctionAux c f 0 = bif f 0 then 1 else 0
state_after: no goals
Theorem: MeasureTheory.lintegral_le_meas
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: apply (lintegral_mono (fun x ↦ ?_)).trans (lintegral_indicator_one_le s)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
⊢ ∫⁻ (a : α), f a ∂μ ≤ μ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
x : α
⊢ f x ≤ s.indicator 1 x

tactic: by_cases hx : x ∈ s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
x : α
⊢ f x ≤ s.indicator 1 x
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
x : α
hx : x ∈ s
⊢ f x ≤ s.indicator 1 x

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
x : α
hx : x ∉ s
⊢ f x ≤ s.indicator 1 x

tactic: simpa [hx] using hf x
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
x : α
hx : x ∈ s
⊢ f x ≤ s.indicator 1 x
state_after: no goals

tactic: simpa [hx] using h'f x hx
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Set α
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≤ 1
h'f : ∀ a ∈ sᶜ, f a = 0
x : α
hx : x ∉ s
⊢ f x ≤ s.indicator 1 x
state_after: no goals
Theorem: BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: have := fun c => l.hasBasis_toFilterDistortioniUnion I c π₀
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
π₀ : Prepartition I
⊢ (l.toFilteriUnion I π₀).HasBasis (fun r => ∀ (c : ℝ≥0), l.RCond (r c)) fun r =>
    {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion}
state_after: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
π₀ : Prepartition I
this :
  ∀ (c : ℝ≥0),
    (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r => {π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion}
⊢ (l.toFilteriUnion I π₀).HasBasis (fun r => ∀ (c : ℝ≥0), l.RCond (r c)) fun r =>
    {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion}

tactic: simpa only [setOf_and, setOf_exists] using hasBasis_iSup this
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
π₀ : Prepartition I
this :
  ∀ (c : ℝ≥0),
    (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r => {π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion}
⊢ (l.toFilteriUnion I π₀).HasBasis (fun r => ∀ (c : ℝ≥0), l.RCond (r c)) fun r =>
    {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion}
state_after: no goals
Theorem: StarConvex.neg
File: Mathlib/Analysis/Convex/Star.lean

tactic: rw [← image_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
⊢ StarConvex 𝕜 (-x) (-s)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
⊢ StarConvex 𝕜 (-x) (Neg.neg '' s)

tactic: exact hs.is_linear_image IsLinearMap.isLinearMap_neg
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
⊢ StarConvex 𝕜 (-x) (Neg.neg '' s)
state_after: no goals
Theorem: Rat.divInt_mul_left
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: if d0 : d = 0 then simp [d0] else
simp [divInt_eq_iff (Int.mul_ne_zero a0 d0) d0, Int.mul_assoc, Int.mul_left_comm]
state_before: n d a : Int
a0 : a ≠ 0
⊢ a * n /. (a * d) = n /. d
state_after: no goals

tactic: simp [d0]
state_before: n d a : Int
a0 : a ≠ 0
d0 : d = 0
⊢ a * n /. (a * d) = n /. d
state_after: no goals

tactic: simp [divInt_eq_iff (Int.mul_ne_zero a0 d0) d0, Int.mul_assoc, Int.mul_left_comm]
state_before: n d a : Int
a0 : a ≠ 0
d0 : ¬d = 0
⊢ a * n /. (a * d) = n /. d
state_after: no goals
Theorem: CategoryTheory.Limits.limit.lift_pre
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
c : Cone F
⊢ lift F c ≫ pre F E = lift (E ⋙ F) (Cone.whisker E c)
state_after: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
c : Cone F
j✝ : K
⊢ (lift F c ≫ pre F E) ≫ π (E ⋙ F) j✝ = lift (E ⋙ F) (Cone.whisker E c) ≫ π (E ⋙ F) j✝

tactic: simp
state_before: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
c : Cone F
j✝ : K
⊢ (lift F c ≫ pre F E) ≫ π (E ⋙ F) j✝ = lift (E ⋙ F) (Cone.whisker E c) ≫ π (E ⋙ F) j✝
state_after: no goals
Theorem: AlgHomClass.unitization_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

tactic: refine AlgHomClass.unitization_injective' s (fun r hr hr' ↦ ?_) f hf
state_before: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
⊢ Function.Injective ⇑f
state_after: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : (algebraMap R A) r ∈ s
⊢ False

tactic: rw [Algebra.algebraMap_eq_smul_one] at hr'
state_before: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : (algebraMap R A) r ∈ s
⊢ False
state_after: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : r • 1 ∈ s
⊢ False

tactic: exact h1 <| inv_smul_smul₀ hr (1 : A) ▸ SMulMemClass.smul_mem r⁻¹ hr'
state_before: F : Type u_1
R : Type u_2
S : Type u_3
A : Type u_4
inst✝⁵ : Field R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
inst✝¹ : FunLike F (Unitization R ↥s) A
inst✝ : AlgHomClass F R (Unitization R ↥s) A
f : F
hf : ∀ (x : ↥s), f ↑x = ↑x
r : R
hr : r ≠ 0
hr' : r • 1 ∈ s
⊢ False
state_after: no goals
Theorem: swap_hammingDist
File: Mathlib/InformationTheory/Hamming.lean

tactic: funext x y
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
⊢ swap hammingDist = hammingDist
state_after: case h.h
α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ swap hammingDist x y = hammingDist x y

tactic: exact hammingDist_comm _ _
state_before: case h.h
α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ swap hammingDist x y = hammingDist x y
state_after: no goals
Theorem: Ordinal.add_mul_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: induction c using limitRecOn with
| H₁ => simp only [succ_zero, mul_one]
| H₂ c IH =>
  rw [mul_succ, IH, ← add_assoc, add_assoc _ b, ba, ← mul_succ]
| H₃ c l IH =>
  rw [mul_succ, add_mul_limit_aux ba l IH, mul_succ, add_assoc]
state_before: a b c : Ordinal.{u_1}
ba : b + a = a
⊢ (a + b) * succ c = a * succ c + b
state_after: no goals

tactic: simp only [succ_zero, mul_one]
state_before: case H₁
a b : Ordinal.{u_1}
ba : b + a = a
⊢ (a + b) * succ 0 = a * succ 0 + b
state_after: no goals

tactic: rw [mul_succ, IH, ← add_assoc, add_assoc _ b, ba, ← mul_succ]
state_before: case H₂
a b : Ordinal.{u_1}
ba : b + a = a
c : Ordinal.{u_1}
IH : (a + b) * succ c = a * succ c + b
⊢ (a + b) * succ (succ c) = a * succ (succ c) + b
state_after: no goals

tactic: rw [mul_succ, add_mul_limit_aux ba l IH, mul_succ, add_assoc]
state_before: case H₃
a b : Ordinal.{u_1}
ba : b + a = a
c : Ordinal.{u_1}
l : c.IsLimit
IH : ∀ o' < c, (a + b) * succ o' = a * succ o' + b
⊢ (a + b) * succ c = a * succ c + b
state_after: no goals
Theorem: Isometry.lipschitzWith_iff
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp [LipschitzWith, h.edist_eq]
state_before: ι : Type u_1
α✝ : Type u
β✝ : Type v
γ✝ : Type w
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
g : β → γ
K : ℝ≥0
h : Isometry g
⊢ LipschitzWith K (g ∘ f) ↔ LipschitzWith K f
state_after: no goals
Theorem: NNReal.closedBall_zero_eq_Icc
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: convert NNReal.closedBall_zero_eq_Icc' ⟨c, c_nn⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
c_nn : 0 ≤ c
⊢ closedBall 0 c = Icc 0 c.toNNReal
state_after: case h.e'_3.h.e'_4
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
c_nn : 0 ≤ c
⊢ c.toNNReal = ⟨c, c_nn⟩

tactic: simp [Real.toNNReal, c_nn]
state_before: case h.e'_3.h.e'_4
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ
c_nn : 0 ≤ c
⊢ c.toNNReal = ⟨c, c_nn⟩
state_after: no goals
Theorem: ZMod.ringHom_map_cast
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
R : Type u_1
inst✝ : Ring R
f : R →+* ZMod n
k : ZMod n
⊢ f k.cast = k
state_after: case zero
R : Type u_1
inst✝ : Ring R
f : R →+* ZMod 0
k : ZMod 0
⊢ f k.cast = k

case succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
f : R →+* ZMod (n✝ + 1)
k : ZMod (n✝ + 1)
⊢ f k.cast = k

tactic: dsimp [ZMod, ZMod.cast] at f k ⊢
state_before: case zero
R : Type u_1
inst✝ : Ring R
f : R →+* ZMod 0
k : ZMod 0
⊢ f k.cast = k
state_after: case zero
R : Type u_1
inst✝ : Ring R
f : R →+* ℤ
k : ℤ
⊢ f ↑k = k

tactic: simp
state_before: case zero
R : Type u_1
inst✝ : Ring R
f : R →+* ℤ
k : ℤ
⊢ f ↑k = k
state_after: no goals

tactic: dsimp [ZMod, ZMod.cast] at f k ⊢
state_before: case succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
f : R →+* ZMod (n✝ + 1)
k : ZMod (n✝ + 1)
⊢ f k.cast = k
state_after: case succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
f : R →+* Fin (n✝ + 1)
k : Fin (n✝ + 1)
⊢ f ↑(val k) = k

tactic: erw [map_natCast, Fin.cast_val_eq_self]
state_before: case succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
f : R →+* Fin (n✝ + 1)
k : Fin (n✝ + 1)
⊢ f ↑(val k) = k
state_after: no goals
Theorem: Equiv.Perm.decomposeFin_symm_apply_zero
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: simp [Equiv.Perm.decomposeFin]
state_before: n : ℕ
p : Fin (n + 1)
e : Perm (Fin n)
⊢ (decomposeFin.symm (p, e)) 0 = p
state_after: no goals
Theorem: Fin.left_distrib_aux
File: Mathlib/Data/ZMod/Defs.lean

tactic: rw [mul_add]
state_before: n : ℕ
x✝² x✝¹ x✝ : Fin n
a : ℕ
ha : a < n
b : ℕ
hb : b < n
c : ℕ
hc : c < n
⊢ a * (b + c) ≡ a * b + a * c [MOD n]
state_after: no goals
Theorem: PiLp.nndist_eq_iSup
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: push_cast
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → PseudoMetricSpace (β i)
x y : PiLp ⊤ β
⊢ ↑(nndist x y) = ↑(⨆ i, nndist (x i) (y i))
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → PseudoMetricSpace (β i)
x y : PiLp ⊤ β
⊢ dist x y = ⨆ i, dist (x i) (y i)

tactic: exact dist_eq_iSup _ _
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → PseudoMetricSpace (β i)
x y : PiLp ⊤ β
⊢ dist x y = ⨆ i, dist (x i) (y i)
state_after: no goals
Theorem: Set.mul_subset_range
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rintro _ ⟨a, ha, b, hb, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
⊢ s * t ⊆ range ⇑m
state_after: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (fun x x_1 => x * x_1) a b ∈ range ⇑m

tactic: obtain ⟨a, rfl⟩ := hs ha
state_before: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (fun x x_1 => x * x_1) a b ∈ range ⇑m
state_after: case intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
b : β
hb : b ∈ t
a : α
ha : m a ∈ s
⊢ (fun x x_1 => x * x_1) (m a) b ∈ range ⇑m

tactic: obtain ⟨b, rfl⟩ := ht hb
state_before: case intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
b : β
hb : b ∈ t
a : α
ha : m a ∈ s
⊢ (fun x x_1 => x * x_1) (m a) b ∈ range ⇑m
state_after: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : α
ha : m a ∈ s
b : α
hb : m b ∈ t
⊢ (fun x x_1 => x * x_1) (m a) (m b) ∈ range ⇑m

tactic: exact ⟨a * b, map_mul _ _ _⟩
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : α
ha : m a ∈ s
b : α
hb : m b ∈ t
⊢ (fun x x_1 => x * x_1) (m a) (m b) ∈ range ⇑m
state_after: no goals
Theorem: Function.LeftInverse.eq_rec_eq
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [h]
state_before: α : Sort u_1
β : Sort u_2
γ : β → Sort v
f : α → β
g : β → α
h : LeftInverse g f
C : (a : α) → γ (f a)
a : α
⊢ HEq (C (g (f a))) (C a)
state_after: no goals
Theorem: Nat.even_add
File: Mathlib/Algebra/Group/Nat.lean

tactic: cases' mod_two_eq_zero_or_one m with h₁ h₁ <;> cases' mod_two_eq_zero_or_one n with h₂ h₂ <;>
  simp [even_iff, h₁, h₂, Nat.add_mod]
state_before: m n : ℕ
⊢ Even (m + n) ↔ (Even m ↔ Even n)
state_after: no goals
Theorem: Coheyting.boundary_hnot_hnot
File: Mathlib/Order/Heyting/Boundary.lean

tactic: simp_rw [boundary, hnot_hnot_hnot, inf_comm]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ∂ (￢￢a) = ∂ (￢a)
state_after: no goals
Theorem: Subgroup.unop_closure
File: Mathlib/Algebra/Group/Subgroup/MulOpposite.lean

tactic: simp_rw [closure, unop_sInf, Set.preimage_setOf_eq, Subgroup.op_coe]
state_before: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ (closure s).unop = closure (MulOpposite.op ⁻¹' s)
state_after: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {K | MulOpposite.op ⁻¹' s ⊆ ↑K}

tactic: congr with a
state_before: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {K | MulOpposite.op ⁻¹' s ⊆ ↑K}
state_after: case e_a.h
ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
a : Subgroup G
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {K | MulOpposite.op ⁻¹' s ⊆ ↑K}

tactic: exact MulOpposite.op_surjective.forall
state_before: case e_a.h
ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
a : Subgroup G
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {K | MulOpposite.op ⁻¹' s ⊆ ↑K}
state_after: no goals
Theorem: monovaryOn_iff_smul_rearrangement
File: Mathlib/Algebra/Order/Monovary.lean

tactic: simp [smul_sub, sub_smul, ← add_sub_right_comm, le_sub_iff_add_le, add_comm (f i • g i),
  add_comm (f i • g j)]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
i : ι
x✝¹ : i ∈ s
j : ι
x✝ : j ∈ s
⊢ 0 ≤ (f j - f i) • (g j - g i) ↔ f i • g j + f j • g i ≤ f i • g i + f j • g j
state_after: no goals
Theorem: IsCompact.lift'_closure_nhdsSet
File: Mathlib/Topology/Separation.lean

tactic: refine le_antisymm (fun U hU ↦ ?_) (le_lift'_closure _)
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K : Set X
hK : IsCompact K
⊢ (𝓝ˢ K).lift' closure = 𝓝ˢ K
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K : Set X
hK : IsCompact K
U : Set X
hU : U ∈ 𝓝ˢ K
⊢ U ∈ (𝓝ˢ K).lift' closure

tactic: rcases hK.exists_isOpen_closure_subset hU with ⟨V, hVo, hKV, hVU⟩
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K : Set X
hK : IsCompact K
U : Set X
hU : U ∈ 𝓝ˢ K
⊢ U ∈ (𝓝ˢ K).lift' closure
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K : Set X
hK : IsCompact K
U : Set X
hU : U ∈ 𝓝ˢ K
V : Set X
hVo : IsOpen V
hKV : K ⊆ V
hVU : closure V ⊆ U
⊢ U ∈ (𝓝ˢ K).lift' closure

tactic: exact mem_of_superset (mem_lift' <| hVo.mem_nhdsSet.2 hKV) hVU
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K : Set X
hK : IsCompact K
U : Set X
hU : U ∈ 𝓝ˢ K
V : Set X
hVo : IsOpen V
hKV : K ⊆ V
hVU : closure V ⊆ U
⊢ U ∈ (𝓝ˢ K).lift' closure
state_after: no goals