1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: TruncatedWittVector.coeff_truncate
File: Mathlib/RingTheory/WittVector/Truncated.lean

tactic: obtain ⟨y, rfl⟩ := @WittVector.truncate_surjective p _ _ _ _ x
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
i : Fin n
x : TruncatedWittVector p m R
⊢ coeff i ((truncate hm) x) = coeff (Fin.castLE hm i) x
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
i : Fin n
y : 𝕎 R
⊢ coeff i ((truncate hm) ((WittVector.truncate m) y)) = coeff (Fin.castLE hm i) ((WittVector.truncate m) y)

tactic: simp only [truncate_wittVector_truncate, WittVector.coeff_truncate, Fin.coe_castLE]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
i : Fin n
y : 𝕎 R
⊢ coeff i ((truncate hm) ((WittVector.truncate m) y)) = coeff (Fin.castLE hm i) ((WittVector.truncate m) y)
state_after: no goals
Theorem: MeasureTheory.Measure.addHaar_ball_of_pos
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rw [← addHaar_ball_mul_of_pos μ x hr, mul_one]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
x : E
r : ℝ
hr : 0 < r
⊢ μ (ball x r) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 1)
state_after: no goals
Theorem: Real.Angle.abs_sin_eq_of_two_nsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_nsmul_eq_iff] at h
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ |θ.sin| = |ψ.sin|
state_after: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ |θ.sin| = |ψ.sin|

tactic: rcases h with (rfl | rfl)
state_before: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ |θ.sin| = |ψ.sin|
state_after: case inl
θ : Angle
⊢ |θ.sin| = |θ.sin|

case inr
ψ : Angle
⊢ |(ψ + ↑π).sin| = |ψ.sin|

tactic: rfl
state_before: case inl
θ : Angle
⊢ |θ.sin| = |θ.sin|
state_after: no goals

tactic: rw [sin_add_pi, abs_neg]
state_before: case inr
ψ : Angle
⊢ |(ψ + ↑π).sin| = |ψ.sin|
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RightFractionRel.op
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: obtain ⟨Z, t₁, t₂, hs, hf, ht⟩ := h
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.131896, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝ : L.IsLocalization W
X Y : C
z₁ z₂ : W.RightFraction X Y
h : RightFractionRel z₁ z₂
⊢ LeftFractionRel z₁.op z₂.op
state_after: case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.131896, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝ : L.IsLocalization W
X Y : C
z₁ z₂ : W.RightFraction X Y
Z : C
t₁ : Z ⟶ z₁.X'
t₂ : Z ⟶ z₂.X'
hs : t₁ ≫ z₁.s = t₂ ≫ z₂.s
hf : t₁ ≫ z₁.f = t₂ ≫ z₂.f
ht : W (t₁ ≫ z₁.s)
⊢ LeftFractionRel z₁.op z₂.op

tactic: exact ⟨Opposite.op Z, t₁.op, t₂.op, Quiver.Hom.unop_inj hs,
  Quiver.Hom.unop_inj hf, ht⟩
state_before: case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.131896, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝ : L.IsLocalization W
X Y : C
z₁ z₂ : W.RightFraction X Y
Z : C
t₁ : Z ⟶ z₁.X'
t₂ : Z ⟶ z₂.X'
hs : t₁ ≫ z₁.s = t₂ ≫ z₂.s
hf : t₁ ≫ z₁.f = t₂ ≫ z₂.f
ht : W (t₁ ≫ z₁.s)
⊢ LeftFractionRel z₁.op z₂.op
state_after: no goals
Theorem: ZNum.cast_bitm1
File: Mathlib/Data/Num/Lemmas.lean

tactic: conv =>
  lhs
  rw [← zneg_zneg n]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑n.bitm1 = _root_.bit0 ↑n - 1
state_after: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑(- -n).bitm1 = _root_.bit0 ↑n - 1

tactic: rw [← zneg_bit1, cast_zneg, cast_bit1]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑(- -n).bitm1 = _root_.bit0 ↑n - 1
state_after: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ -_root_.bit1 ↑(-n) = _root_.bit0 ↑n - 1

tactic: have : ((-1 + n + n : ℤ) : α) = (n + n + -1 : ℤ) := by simp [add_comm, add_left_comm]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ -_root_.bit1 ↑(-n) = _root_.bit0 ↑n - 1
state_after: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
this : ↑(-1 + ↑n + ↑n) = ↑(↑n + ↑n + -1)
⊢ -_root_.bit1 ↑(-n) = _root_.bit0 ↑n - 1

tactic: simpa [_root_.bit1, _root_.bit0, sub_eq_add_neg] using this
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
this : ↑(-1 + ↑n + ↑n) = ↑(↑n + ↑n + -1)
⊢ -_root_.bit1 ↑(-n) = _root_.bit0 ↑n - 1
state_after: no goals

tactic: simp [add_comm, add_left_comm]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑(-1 + ↑n + ↑n) = ↑(↑n + ↑n + -1)
state_after: no goals
Theorem: HahnSeries.coeff_eq_zero_of_lt_order
File: Mathlib/RingTheory/HahnSeries/Basic.lean

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hi : i < x.order
⊢ x.coeff i = 0
state_after: case inl
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
i : Γ
hi : i < order 0
⊢ coeff 0 i = 0

case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hi : i < x.order
hx : x ≠ 0
⊢ x.coeff i = 0

tactic: contrapose! hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hi : i < x.order
hx : x ≠ 0
⊢ x.coeff i = 0
state_after: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : x.coeff i ≠ 0
⊢ ¬i < x.order

tactic: rw [← mem_support] at hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : x.coeff i ≠ 0
⊢ ¬i < x.order
state_after: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬i < x.order

tactic: rw [order_of_ne hx]
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬i < x.order
state_after: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬i < ⋯.min ⋯

tactic: exact Set.IsWF.not_lt_min _ _ hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬i < ⋯.min ⋯
state_after: no goals

tactic: simp
state_before: case inl
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
i : Γ
hi : i < order 0
⊢ coeff 0 i = 0
state_after: no goals
Theorem: LinearMap.IsRefl.nondegenerate_of_separatingLeft
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: refine ⟨hB', ?_⟩
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] M₁
hB : B.IsRefl
hB' : B.SeparatingLeft
⊢ B.Nondegenerate
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] M₁
hB : B.IsRefl
hB' : B.SeparatingLeft
⊢ B.SeparatingRight

tactic: rw [separatingRight_iff_flip_ker_eq_bot, hB.ker_eq_bot_iff_ker_flip_eq_bot.mp]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] M₁
hB : B.IsRefl
hB' : B.SeparatingLeft
⊢ B.SeparatingRight
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] M₁
hB : B.IsRefl
hB' : B.SeparatingLeft
⊢ ker B = ⊥

tactic: rwa [← separatingLeft_iff_ker_eq_bot]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] M₁
hB : B.IsRefl
hB' : B.SeparatingLeft
⊢ ker B = ⊥
state_after: no goals
Theorem: Mathlib.Tactic.Ring.add_pf_add_overlap
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ b₁ c₁ a₂ b₂ c₂ : R
x✝¹ : a₁ + b₁ = c₁
x✝ : a₂ + b₂ = c₂
⊢ a₁ + a₂ + (b₁ + b₂) = c₁ + c₂
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ b₁ a₂ b₂ : R
⊢ a₁ + a₂ + (b₁ + b₂) = a₁ + b₁ + (a₂ + b₂)

tactic: simp [add_assoc, add_left_comm]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ b₁ a₂ b₂ : R
⊢ a₁ + a₂ + (b₁ + b₂) = a₁ + b₁ + (a₂ + b₂)
state_after: no goals
Theorem: ArithmeticFunction.pdiv_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : DivisionSemiring R
f : ArithmeticFunction R
⊢ f.pdiv ↑ζ = f
state_after: case h
R : Type u_1
inst✝ : DivisionSemiring R
f : ArithmeticFunction R
n : ℕ
⊢ (f.pdiv ↑ζ) n = f n

tactic: cases n <;> simp [succ_ne_zero]
state_before: case h
R : Type u_1
inst✝ : DivisionSemiring R
f : ArithmeticFunction R
n : ℕ
⊢ (f.pdiv ↑ζ) n = f n
state_after: no goals
Theorem: min_def
File: Mathlib/Init/Order/LinearOrder.lean

tactic: rw [LinearOrder.min_def a]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ min a b = if a ≤ b then a else b
state_after: no goals
Theorem: irreducible_pow_sup
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [sup_eq_prod_inf_factors (pow_ne_zero n hJ.ne_zero) hI, min_comm,
  normalizedFactors_of_irreducible_pow hJ, normalize_eq J, replicate_inter, prod_replicate]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Field K
T : Type u_4
inst✝¹ : CommRing T
inst✝ : IsDedekindDomain T
I J : Ideal T
hI : I ≠ ⊥
hJ : Irreducible J
n : ℕ
⊢ J ^ n ⊔ I = J ^ min (count J (normalizedFactors I)) n
state_after: no goals
Theorem: Int.zpow_log_le_self
File: Mathlib/Data/Int/Log.lean

tactic: rcases le_total 1 r with hr1 | hr1
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
⊢ ↑b ^ log b r ≤ r
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ ↑b ^ log b r ≤ r

case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : r ≤ 1
⊢ ↑b ^ log b r ≤ r

tactic: rw [log_of_one_le_right _ hr1]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ ↑b ^ log b r ≤ r
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ ↑b ^ ↑(Nat.log b ⌊r⌋₊) ≤ r

tactic: rw [zpow_natCast, ← Nat.cast_pow, ← Nat.le_floor_iff hr.le]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ ↑b ^ ↑(Nat.log b ⌊r⌋₊) ≤ r
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ b ^ Nat.log b ⌊r⌋₊ ≤ ⌊r⌋₊

tactic: exact Nat.pow_log_le_self b (Nat.floor_pos.mpr hr1).ne'
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ b ^ Nat.log b ⌊r⌋₊ ≤ ⌊r⌋₊
state_after: no goals

tactic: rw [log_of_right_le_one _ hr1, zpow_neg, zpow_natCast, ← Nat.cast_pow]
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : r ≤ 1
⊢ ↑b ^ log b r ≤ r
state_after: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : r ≤ 1
⊢ (↑(b ^ Nat.clog b ⌈r⁻¹⌉₊))⁻¹ ≤ r

tactic: exact inv_le_of_inv_le hr (Nat.ceil_le.1 <| Nat.le_pow_clog hb _)
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : r ≤ 1
⊢ (↑(b ^ Nat.clog b ⌈r⁻¹⌉₊))⁻¹ ≤ r
state_after: no goals
Theorem: DirectedOn.strictConvex_sUnion
File: Mathlib/Analysis/Convex/Strict.lean

tactic: rw [sUnion_eq_iUnion]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x y : E
a b : 𝕜
S : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) S
hS : ∀ s ∈ S, StrictConvex 𝕜 s
⊢ StrictConvex 𝕜 (⋃₀ S)
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x y : E
a b : 𝕜
S : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) S
hS : ∀ s ∈ S, StrictConvex 𝕜 s
⊢ StrictConvex 𝕜 (⋃ i, ↑i)

tactic: exact (directedOn_iff_directed.1 hdir).strictConvex_iUnion fun s => hS _ s.2
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x y : E
a b : 𝕜
S : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) S
hS : ∀ s ∈ S, StrictConvex 𝕜 s
⊢ StrictConvex 𝕜 (⋃ i, ↑i)
state_after: no goals
Theorem: jacobiSym.eq_zero_iff_not_coprime
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: rw [List.mem_pmap, Int.gcd_eq_natAbs, Ne, Prime.not_coprime_iff_dvd]
state_before: a : ℤ
b : ℕ
inst✝ : NeZero b
⊢ 0 ∈ List.pmap (fun p pp => legendreSym p a) b.factors ⋯ ↔ a.gcd ↑b ≠ 1
state_after: a : ℤ
b : ℕ
inst✝ : NeZero b
⊢ (∃ a_1, ∃ (h : a_1 ∈ b.factors), legendreSym a_1 a = 0) ↔ ∃ p, Nat.Prime p ∧ p ∣ a.natAbs ∧ p ∣ (↑b).natAbs

tactic: simp_rw [legendreSym.eq_zero_iff _ _, intCast_zmod_eq_zero_iff_dvd,
  mem_factors (NeZero.ne b), ← Int.natCast_dvd, Int.natCast_dvd_natCast, exists_prop,
  and_assoc, and_comm]
state_before: a : ℤ
b : ℕ
inst✝ : NeZero b
⊢ (∃ a_1, ∃ (h : a_1 ∈ b.factors), legendreSym a_1 a = 0) ↔ ∃ p, Nat.Prime p ∧ p ∣ a.natAbs ∧ p ∣ (↑b).natAbs
state_after: no goals
Theorem: List.getElem_inits
File: Mathlib/Data/List/Infix.lean

tactic: induction l generalizing n with
| nil => simp
| cons a l ihl =>
  cases n with
  | zero => simp
  | succ n => simp [ihl]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l : List α
n : ℕ
h : n < l.inits.length
⊢ l.inits[n] = take n l
state_after: no goals

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n✝ n : ℕ
h : n < [].inits.length
⊢ [].inits[n] = take n []
state_after: no goals

tactic: cases n with
| zero => simp
| succ n => simp [ihl]
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n✝ : ℕ
a : α
l : List α
ihl : ∀ (n : ℕ) (h : n < l.inits.length), l.inits[n] = take n l
n : ℕ
h : n < (a :: l).inits.length
⊢ (a :: l).inits[n] = take n (a :: l)
state_after: no goals

tactic: simp
state_before: case cons.zero
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
l : List α
ihl : ∀ (n : ℕ) (h : n < l.inits.length), l.inits[n] = take n l
h : 0 < (a :: l).inits.length
⊢ (a :: l).inits[0] = take 0 (a :: l)
state_after: no goals

tactic: simp [ihl]
state_before: case cons.succ
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n✝ : ℕ
a : α
l : List α
ihl : ∀ (n : ℕ) (h : n < l.inits.length), l.inits[n] = take n l
n : ℕ
h : n + 1 < (a :: l).inits.length
⊢ (a :: l).inits[n + 1] = take (n + 1) (a :: l)
state_after: no goals
Theorem: MeasureTheory.condexp_stopping_time_ae_eq_restrict_eq_of_countable_range
File: Mathlib/Probability/Process/Stopping.lean

tactic: refine condexp_ae_eq_restrict_of_measurableSpace_eq_on
  (hτ.measurableSpace_le_of_countable_range h_countable) (ℱ.le i)
  (hτ.measurableSet_eq_of_countable_range' h_countable i) fun t => ?_
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
μ : Measure Ω
ℱ : Filtration ι m
τ σ : Ω → ι
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : Ω → E
inst✝¹ : SigmaFiniteFiltration μ ℱ
hτ : IsStoppingTime ℱ τ
h_countable : (Set.range τ).Countable
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
⊢ μ[f|hτ.measurableSpace] =ᶠ[ae (μ.restrict {x | τ x = i})] μ[f|↑ℱ i]
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
μ : Measure Ω
ℱ : Filtration ι m
τ σ : Ω → ι
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : Ω → E
inst✝¹ : SigmaFiniteFiltration μ ℱ
hτ : IsStoppingTime ℱ τ
h_countable : (Set.range τ).Countable
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
t : Set Ω
⊢ MeasurableSet ({x | τ x = i} ∩ t) ↔ MeasurableSet ({x | τ x = i} ∩ t)

tactic: rw [Set.inter_comm _ t, IsStoppingTime.measurableSet_inter_eq_iff]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : LinearOrder ι
μ : Measure Ω
ℱ : Filtration ι m
τ σ : Ω → ι
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : Ω → E
inst✝¹ : SigmaFiniteFiltration μ ℱ
hτ : IsStoppingTime ℱ τ
h_countable : (Set.range τ).Countable
inst✝ : SigmaFinite (μ.trim ⋯)
i : ι
t : Set Ω
⊢ MeasurableSet ({x | τ x = i} ∩ t) ↔ MeasurableSet ({x | τ x = i} ∩ t)
state_after: no goals
Theorem: Set.range_list_getI
File: Mathlib/Data/Set/List.lean

tactic: unfold List.getI
state_before: α : Type u_1
β : Type u_2
l✝ : List α
inst✝ : Inhabited α
l : List α
⊢ range l.getI = insert default {x | x ∈ l}
state_after: α : Type u_1
β : Type u_2
l✝ : List α
inst✝ : Inhabited α
l : List α
⊢ (range fun n => l.getD n default) = insert default {x | x ∈ l}

tactic: simp
state_before: α : Type u_1
β : Type u_2
l✝ : List α
inst✝ : Inhabited α
l : List α
⊢ (range fun n => l.getD n default) = insert default {x | x ∈ l}
state_after: no goals
Theorem: Finset.univ_map_equiv_to_embedding
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
inst✝² : Fintype α✝
s t : Finset α✝
α : Type u_4
β : Type u_5
inst✝¹ : Fintype α
inst✝ : Fintype β
e : α ≃ β
b : β
⊢ e.toEmbedding (e.symm b) = b
state_after: no goals
Theorem: LieModuleEquiv.range_coe
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [LieModuleHom.range_eq_top]
state_before: R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
M : Type u_1
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : LieRingModule L M
inst✝³ : LieModule R L M
M' : Type u_2
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
inst✝ : LieRingModule L M'
e : M ≃ₗ⁅R,L⁆ M'
⊢ e.range = ⊤
state_after: R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
M : Type u_1
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : LieRingModule L M
inst✝³ : LieModule R L M
M' : Type u_2
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
inst✝ : LieRingModule L M'
e : M ≃ₗ⁅R,L⁆ M'
⊢ Function.Surjective ⇑e.toLieModuleHom

tactic: exact e.surjective
state_before: R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
M : Type u_1
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : LieRingModule L M
inst✝³ : LieModule R L M
M' : Type u_2
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
inst✝ : LieRingModule L M'
e : M ≃ₗ⁅R,L⁆ M'
⊢ Function.Surjective ⇑e.toLieModuleHom
state_after: no goals
Theorem: t0Space_iff_or_not_mem_closure
File: Mathlib/Topology/Separation.lean

tactic: simp only [t0Space_iff_not_inseparable, inseparable_iff_mem_closure, not_and_or]
state_before: X✝ : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X✝
X : Type u
inst✝ : TopologicalSpace X
⊢ T0Space X ↔ Pairwise fun a b => a ∉ closure {b} ∨ b ∉ closure {a}
state_after: no goals