1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: dvd_of_one_le_padicValNat
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: by_contra h
state_before: p n : ℕ
hp : 1 ≤ padicValNat p n
⊢ p ∣ n
state_after: p n : ℕ
hp : 1 ≤ padicValNat p n
h : ¬p ∣ n
⊢ False

tactic: rw [padicValNat.eq_zero_of_not_dvd h] at hp
state_before: p n : ℕ
hp : 1 ≤ padicValNat p n
h : ¬p ∣ n
⊢ False
state_after: p n : ℕ
hp : 1 ≤ 0
h : ¬p ∣ n
⊢ False

tactic: exact lt_irrefl 0 (lt_of_lt_of_le zero_lt_one hp)
state_before: p n : ℕ
hp : 1 ≤ 0
h : ¬p ∣ n
⊢ False
state_after: no goals
Theorem: ContinuousLinearMap.intervalIntegral_comp_comm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp_rw [intervalIntegral, L.integral_comp_comm hf.1, L.integral_comp_comm hf.2, L.map_sub]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NormedSpace ℝ E
a b : ℝ
μ : Measure ℝ
f : ℝ → E
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
L : E →L[𝕜] F
hf : IntervalIntegrable f μ a b
⊢ ∫ (x : ℝ) in a..b, L (f x) ∂μ = L (∫ (x : ℝ) in a..b, f x ∂μ)
state_after: no goals
Theorem: Int.induction_on
File: Mathlib/Data/Int/Defs.lean

tactic: induction i with
| ofNat i =>
  induction i with
  | zero => exact hz
  | succ i ih => exact hp _ ih
| negSucc i =>
  suffices ∀ n : ℕ, p (-n) from this (i + 1)
  intro n; induction n with
  | zero => simp [hz]
  | succ n ih => convert hn _ ih using 1; simp [ofNat_succ, Int.neg_add, Int.sub_eq_add_neg]
state_before: a b c d m n : ℤ
p : ℤ → Prop
i : ℤ
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
⊢ p i
state_after: no goals

tactic: induction i with
| zero => exact hz
| succ i ih => exact hp _ ih
state_before: case ofNat
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ p (ofNat i)
state_after: no goals

tactic: exact hz
state_before: case ofNat.zero
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
⊢ p (ofNat 0)
state_after: no goals

tactic: exact hp _ ih
state_before: case ofNat.succ
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
ih : p (ofNat i)
⊢ p (ofNat (i + 1))
state_after: no goals

tactic: suffices ∀ n : ℕ, p (-n) from this (i + 1)
state_before: case negSucc
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ p -[i+1]
state_after: case negSucc
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ ∀ (n : ℕ), p (-↑n)

tactic: intro n
state_before: case negSucc
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ ∀ (n : ℕ), p (-↑n)
state_after: case negSucc
a b c d m n✝ : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
⊢ p (-↑n)

tactic: induction n with
| zero => simp [hz]
| succ n ih => convert hn _ ih using 1; simp [ofNat_succ, Int.neg_add, Int.sub_eq_add_neg]
state_before: case negSucc
a b c d m n✝ : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
⊢ p (-↑n)
state_after: no goals

tactic: simp [hz]
state_before: case negSucc.zero
a b c d m n : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ p (-↑0)
state_after: no goals

tactic: convert hn _ ih using 1
state_before: case negSucc.succ
a b c d m n✝ : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
ih : p (-↑n)
⊢ p (-↑(n + 1))
state_after: case h.e'_1
a b c d m n✝ : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
ih : p (-↑n)
⊢ -↑(n + 1) = -↑n - 1

tactic: simp [ofNat_succ, Int.neg_add, Int.sub_eq_add_neg]
state_before: case h.e'_1
a b c d m n✝ : ℤ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
ih : p (-↑n)
⊢ -↑(n + 1) = -↑n - 1
state_after: no goals
Theorem: MvPFunctor.comp_wPathCasesOn
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: ext i x
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u_1} n
β : TypeVec.{u_2} n
h : α ⟹ β
a : P.A
f : P.last.B a → P.last.W
g' : P.drop.B a ⟹ α
g : (j : P.last.B a) → P.WPath (f j) ⟹ α
⊢ h ⊚ P.wPathCasesOn g' g = P.wPathCasesOn (h ⊚ g') fun i => h ⊚ g i
state_after: case a.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u_1} n
β : TypeVec.{u_2} n
h : α ⟹ β
a : P.A
f : P.last.B a → P.last.W
g' : P.drop.B a ⟹ α
g : (j : P.last.B a) → P.WPath (f j) ⟹ α
i : Fin2 n
x : P.WPath (WType.mk a f) i
⊢ (h ⊚ P.wPathCasesOn g' g) i x = P.wPathCasesOn (h ⊚ g') (fun i => h ⊚ g i) i x

tactic: cases x <;> rfl
state_before: case a.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u_1} n
β : TypeVec.{u_2} n
h : α ⟹ β
a : P.A
f : P.last.B a → P.last.W
g' : P.drop.B a ⟹ α
g : (j : P.last.B a) → P.WPath (f j) ⟹ α
i : Fin2 n
x : P.WPath (WType.mk a f) i
⊢ (h ⊚ P.wPathCasesOn g' g) i x = P.wPathCasesOn (h ⊚ g') (fun i => h ⊚ g i) i x
state_after: no goals
Theorem: Set.Icc.coe_eq_one
File: Mathlib/Algebra/Order/Interval/Set/Instances.lean

tactic: symm
state_before: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ ↑x = 1 ↔ x = 1
state_after: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ x = 1 ↔ ↑x = 1

tactic: exact Subtype.ext_iff
state_before: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ x = 1 ↔ ↑x = 1
state_after: no goals
Theorem: CategoryTheory.Limits.IsImage.isoExt_inv_m
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF.isoExt hF').inv ≫ F.m = F'.m
state_after: no goals
Theorem: Set.image_const_sub_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: have := image_comp (fun x => a + x) fun x => -x
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a - x) '' Ioc b c = Ico (a - c) (a - b)
state_after: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioc b c = Ico (a - c) (a - b)

tactic: dsimp [Function.comp_def] at this
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioc b c = Ico (a - c) (a - b)
state_after: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioc b c = Ico (a - c) (a - b)

tactic: simp [sub_eq_add_neg, this, add_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioc b c = Ico (a - c) (a - b)
state_after: no goals
Theorem: EuclideanGeometry.inversion_zero_radius
File: Mathlib/Geometry/Euclidean/Inversion/Basic.lean

tactic: simp [inversion]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
r R : ℝ
c x : P
⊢ inversion c 0 x = c
state_after: no goals
Theorem: Real.comap_toNNReal_atTop
File: Mathlib/Topology/Instances/NNReal.lean

tactic: refine le_antisymm ?_ tendsto_real_toNNReal_atTop.le_comap
state_before: α : Type u_1
⊢ comap Real.toNNReal atTop = atTop
state_after: α : Type u_1
⊢ comap Real.toNNReal atTop ≤ atTop

tactic: refine (atTop_basis_Ioi' 0).ge_iff.2 fun a ha ↦ ?_
state_before: α : Type u_1
⊢ comap Real.toNNReal atTop ≤ atTop
state_after: α : Type u_1
a : ℝ
ha : 0 < a
⊢ Set.Ioi a ∈ comap Real.toNNReal atTop

tactic: filter_upwards [preimage_mem_comap (Ioi_mem_atTop a.toNNReal)] with x hx
state_before: α : Type u_1
a : ℝ
ha : 0 < a
⊢ Set.Ioi a ∈ comap Real.toNNReal atTop
state_after: case h
α : Type u_1
a : ℝ
ha : 0 < a
x : ℝ
hx : x ∈ Real.toNNReal ⁻¹' Set.Ioi a.toNNReal
⊢ x ∈ Set.Ioi a

tactic: exact (Real.toNNReal_lt_toNNReal_iff_of_nonneg ha.le).1 hx
state_before: case h
α : Type u_1
a : ℝ
ha : 0 < a
x : ℝ
hx : x ∈ Real.toNNReal ⁻¹' Set.Ioi a.toNNReal
⊢ x ∈ Set.Ioi a
state_after: no goals
Theorem: coe_nonZeroDivisorsLeft_eq
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

tactic: ext x
state_before: M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
⊢ ↑(nonZeroDivisorsLeft M₀) = {x | x ≠ 0}
state_after: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
⊢ x ∈ ↑(nonZeroDivisorsLeft M₀) ↔ x ∈ {x | x ≠ 0}

tactic: simp only [SetLike.mem_coe, mem_nonZeroDivisorsLeft_iff, mul_eq_zero, forall_eq_or_imp, true_and,
  Set.mem_setOf_eq]
state_before: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
⊢ x ∈ ↑(nonZeroDivisorsLeft M₀) ↔ x ∈ {x | x ≠ 0}
state_after: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
⊢ (∀ (a : M₀), x = 0 → a = 0) ↔ x ≠ 0

tactic: refine ⟨fun h ↦ ?_, fun hx y hx' ↦ by contradiction⟩
state_before: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
⊢ (∀ (a : M₀), x = 0 → a = 0) ↔ x ≠ 0
state_after: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
h : ∀ (a : M₀), x = 0 → a = 0
⊢ x ≠ 0

tactic: contrapose! h
state_before: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
h : ∀ (a : M₀), x = 0 → a = 0
⊢ x ≠ 0
state_after: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
h : x = 0
⊢ ∃ a, x = 0 ∧ a ≠ 0

tactic: exact ⟨1, h, one_ne_zero⟩
state_before: case h
M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
h : x = 0
⊢ ∃ a, x = 0 ∧ a ≠ 0
state_after: no goals

tactic: contradiction
state_before: M₀ : Type u_1
inst✝² : MonoidWithZero M₀
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
x : M₀
hx : x ≠ 0
y : M₀
hx' : x = 0
⊢ y = 0
state_after: no goals
Theorem: IsAssociatedPrime.map_of_injective
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

tactic: obtain ⟨x, rfl⟩ := h.2
state_before: R : Type u_1
inst✝⁴ : CommRing R
I J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
h : IsAssociatedPrime I M
hf : Function.Injective ⇑f
⊢ IsAssociatedPrime I M'
state_after: case intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : M
h : IsAssociatedPrime (Submodule.span R {x}).annihilator M
⊢ IsAssociatedPrime (Submodule.span R {x}).annihilator M'

tactic: refine ⟨h.1, ⟨f x, ?_⟩⟩
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : M
h : IsAssociatedPrime (Submodule.span R {x}).annihilator M
⊢ IsAssociatedPrime (Submodule.span R {x}).annihilator M'
state_after: case intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : M
h : IsAssociatedPrime (Submodule.span R {x}).annihilator M
⊢ (Submodule.span R {x}).annihilator = (Submodule.span R {f x}).annihilator

tactic: ext r
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : M
h : IsAssociatedPrime (Submodule.span R {x}).annihilator M
⊢ (Submodule.span R {x}).annihilator = (Submodule.span R {f x}).annihilator
state_after: case intro.h
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : M
h : IsAssociatedPrime (Submodule.span R {x}).annihilator M
r : R
⊢ r ∈ (Submodule.span R {x}).annihilator ↔ r ∈ (Submodule.span R {f x}).annihilator

tactic: rw [Submodule.mem_annihilator_span_singleton, Submodule.mem_annihilator_span_singleton, ←
  map_smul, ← f.map_zero, hf.eq_iff]
state_before: case intro.h
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ⇑f
x : M
h : IsAssociatedPrime (Submodule.span R {x}).annihilator M
r : R
⊢ r ∈ (Submodule.span R {x}).annihilator ↔ r ∈ (Submodule.span R {f x}).annihilator
state_after: no goals
Theorem: ball_one_div_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [ball_div_singleton, one_div]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball 1 δ / {x} = ball x⁻¹ δ
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.map_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: by_cases hf : Measurable f
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
⊢ map 0 f = 0
state_after: case pos
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
⊢ map 0 f = 0

case neg
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : ¬Measurable f
⊢ map 0 f = 0

tactic: ext i hi
state_before: case pos
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
⊢ map 0 f = 0
state_after: case pos.h
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
i : Set β
hi : MeasurableSet i
⊢ ↑(map 0 f) i = ↑0 i

tactic: rw [map_apply _ hf hi, zero_apply, zero_apply]
state_before: case pos.h
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
i : Set β
hi : MeasurableSet i
⊢ ↑(map 0 f) i = ↑0 i
state_after: no goals

tactic: exact dif_neg hf
state_before: case neg
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : ¬Measurable f
⊢ map 0 f = 0
state_after: no goals
Theorem: NumberField.ComplexEmbedding.IsReal.comp
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: ext1 x
state_before: K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k →+* K
φ : K →+* ℂ
hφ : IsReal φ
⊢ IsReal (φ.comp f)
state_after: case a
K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k →+* K
φ : K →+* ℂ
hφ : IsReal φ
x : k
⊢ (star (φ.comp f)) x = (φ.comp f) x

tactic: simpa using RingHom.congr_fun hφ (f x)
state_before: case a
K : Type u_1
inst✝¹ : Field K
k : Type u_2
inst✝ : Field k
f : k →+* K
φ : K →+* ℂ
hφ : IsReal φ
x : k
⊢ (star (φ.comp f)) x = (φ.comp f) x
state_after: no goals
Theorem: Ideal.eq_span_singleton_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [le_antisymm_iff, le_span_singleton_mul_iff, span_singleton_mul_le_iff]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ I = span {x} * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I
state_after: no goals
Theorem: LieAlgebra.IsKilling.chainLength_smul
File: Mathlib/Algebra/Lie/Weights/RootSystem.lean

tactic: rw [← nsmul_eq_smul_cast, chainLength_nsmul _ _ hx]
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
x : L
hx : x ∈ rootSpace H ⇑(chainTop (⇑α) β)
⊢ ↑(chainLength α β) • x = ⁅coroot α, x⁆
state_after: no goals
Theorem: Complex.angle_div_left_eq_angle_mul_right
File: Mathlib/Analysis/Complex/Angle.lean

tactic: obtain rfl | ha := eq_or_ne a 0
state_before: a✝ x✝ y✝ a x y : ℂ
⊢ angle (x / a) y = angle x (y * a)
state_after: case inl
a x✝ y✝ x y : ℂ
⊢ angle (x / 0) y = angle x (y * 0)

case inr
a✝ x✝ y✝ a x y : ℂ
ha : a ≠ 0
⊢ angle (x / a) y = angle x (y * a)

tactic: simp
state_before: case inl
a x✝ y✝ x y : ℂ
⊢ angle (x / 0) y = angle x (y * 0)
state_after: no goals

tactic: rw [← angle_mul_right ha, div_mul_cancel₀ _ ha]
state_before: case inr
a✝ x✝ y✝ a x y : ℂ
ha : a ≠ 0
⊢ angle (x / a) y = angle x (y * a)
state_after: no goals
Theorem: MeasureTheory.lintegral_add_left'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_congr_ae hf.ae_eq_mk, ← lintegral_add_left hf.measurable_mk,
  lintegral_congr_ae (hf.ae_eq_mk.add (ae_eq_refl g))]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
g : α → ℝ≥0∞
⊢ ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ
state_after: no goals
Theorem: PFun.fix_fwd
File: Mathlib/Data/PFun.lean

tactic: rwa [← fix_fwd_eq ha']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f : α →. β ⊕ α
b : β
a a' : α
hb : b ∈ f.fix a
ha' : Sum.inr a' ∈ f a
⊢ b ∈ f.fix a'
state_after: no goals
Theorem: iSup_eq_iSup_finset'
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← iSup_eq_iSup_finset, ← Equiv.plift.surjective.iSup_comp]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
ι' : Sort u_7
inst✝ : CompleteLattice α
s : ι' → α
⊢ ⨆ i, s i = ⨆ t, ⨆ i ∈ t, s i.down
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
ι' : Sort u_7
inst✝ : CompleteLattice α
s : ι' → α
⊢ ⨆ x, s (Equiv.plift x) = ⨆ i, s i.down

tactic: rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
ι' : Sort u_7
inst✝ : CompleteLattice α
s : ι' → α
⊢ ⨆ x, s (Equiv.plift x) = ⨆ i, s i.down
state_after: no goals
Theorem: Num.cast_ofZNum
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat, ofZNum_toNat]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑(ofZNum n) = ↑(↑n).toNat
state_after: no goals
Theorem: Nat.xor_left_injective
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [← xor_cancel_right n m, ← xor_cancel_right n m', h]
state_before: n m m' : ℕ
h : m ^^^ n = m' ^^^ n
⊢ m = m'
state_after: no goals
Theorem: Set.surjOn_id
File: Mathlib/Data/Set/Function.lean

tactic: simp [SurjOn, subset_rfl]
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 : β
s : Set α
⊢ SurjOn id s s
state_after: no goals
Theorem: Int.log_inv
File: Mathlib/Data/Int/Log.lean

tactic: rw [← inv_inv r, clog_inv, neg_neg, inv_inv]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
⊢ log b r⁻¹ = -clog b r
state_after: no goals
Theorem: StieltjesFunction.measure_smul
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine Measure.ext_of_Ioc _ _ (fun a b _ ↦ ?_)
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
⊢ (c • f).measure = c • f.measure
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ (c • f).measure (Ioc a b) = (c • f.measure) (Ioc a b)

tactic: simp only [measure_Ioc, Measure.smul_apply]
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ (c • f).measure (Ioc a b) = (c • f.measure) (Ioc a b)
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑(c • f) b - ↑(c • f) a) = c • ofReal (↑f b - ↑f a)

tactic: change ofReal (c * f b - c * f a) = c • ofReal (f b - f a)
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑(c • f) b - ↑(c • f) a) = c • ofReal (↑f b - ↑f a)
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑c * ↑f b - ↑c * ↑f a) = c • ofReal (↑f b - ↑f a)

tactic: rw [← _root_.mul_sub, ENNReal.ofReal_mul zero_le_coe, ofReal_coe_nnreal, ← smul_eq_mul]
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑c * ↑f b - ↑c * ↑f a) = c • ofReal (↑f b - ↑f a)
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ↑c • ofReal (↑f b - ↑f a) = c • ofReal (↑f b - ↑f a)

tactic: rfl
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ↑c • ofReal (↑f b - ↑f a) = c • ofReal (↑f b - ↑f a)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.nonsingular_neg
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: by_cases hPz : P z = 0
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
⊢ W.Nonsingular (W.neg P)
state_after: case pos
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
hPz : P z = 0
⊢ W.Nonsingular (W.neg P)

case neg
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
hPz : ¬P z = 0
⊢ W.Nonsingular (W.neg P)

tactic: simp only [neg_of_Z_eq_zero hP hPz, nonsingular_smul _
    ((isUnit_Y_of_Z_eq_zero hP hPz).div <| isUnit_X_of_Z_eq_zero hP hPz).neg, nonsingular_zero]
state_before: case pos
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
hPz : P z = 0
⊢ W.Nonsingular (W.neg P)
state_after: no goals

tactic: simp only [neg_of_Z_ne_zero hPz, nonsingular_smul _ <| Ne.isUnit hPz,
  nonsingular_neg_of_Z_ne_zero hP hPz]
state_before: case neg
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
hPz : ¬P z = 0
⊢ W.Nonsingular (W.neg P)
state_after: no goals
Theorem: Set.projIcc_eq_right
File: Mathlib/Order/Interval/Set/ProjIcc.lean

tactic: simp [projIcc, Subtype.ext_iff, max_min_distrib_left, h.le, h.not_le]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h✝ : a ≤ b
x : α
h : a < b
⊢ projIcc a b ⋯ x = ⟨b, ⋯⟩ ↔ b ≤ x
state_after: no goals
Theorem: Nat.dvd_iff_div_mul_eq
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [← h]
state_before: a b c d✝ m n✝ k : ℕ
p q : ℕ → Prop
n d : ℕ
h : n / d * d = n
⊢ d ∣ n
state_after: a b c d✝ m n✝ k : ℕ
p q : ℕ → Prop
n d : ℕ
h : n / d * d = n
⊢ d ∣ n / d * d

tactic: exact Nat.dvd_mul_left _ _
state_before: a b c d✝ m n✝ k : ℕ
p q : ℕ → Prop
n d : ℕ
h : n / d * d = n
⊢ d ∣ n / d * d
state_after: no goals