1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ProbabilityTheory.inter_pos_of_cond_ne_zero
File: Mathlib/Probability/ConditionalProbability.lean

tactic: refine pos_iff_ne_zero.mpr (right_ne_zero_of_mul (a := (μ s)⁻¹) ?_)
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hms : MeasurableSet s
hcst : μ[|s] t ≠ 0
⊢ 0 < μ (s ∩ t)
state_after: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hms : MeasurableSet s
hcst : μ[|s] t ≠ 0
⊢ (μ s)⁻¹ * μ (s ∩ t) ≠ 0

tactic: convert hcst
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hms : MeasurableSet s
hcst : μ[|s] t ≠ 0
⊢ (μ s)⁻¹ * μ (s ∩ t) ≠ 0
state_after: case h.e'_2
Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hms : MeasurableSet s
hcst : μ[|s] t ≠ 0
⊢ (μ s)⁻¹ * μ (s ∩ t) = μ[|s] t

tactic: simp [hms, Set.inter_comm, cond]
state_before: case h.e'_2
Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hms : MeasurableSet s
hcst : μ[|s] t ≠ 0
⊢ (μ s)⁻¹ * μ (s ∩ t) = μ[|s] t
state_after: no goals
Theorem: RingHom.range_eq_map
File: Mathlib/Algebra/Ring/Subring/Basic.lean

tactic: ext
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
g : S →+* T
f✝ f : R →+* S
⊢ f.range = Subring.map f ⊤
state_after: case h
R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
g : S →+* T
f✝ f : R →+* S
x✝ : S
⊢ x✝ ∈ f.range ↔ x✝ ∈ Subring.map f ⊤

tactic: simp
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
g : S →+* T
f✝ f : R →+* S
x✝ : S
⊢ x✝ ∈ f.range ↔ x✝ ∈ Subring.map f ⊤
state_after: no goals
Theorem: Submodule.prodEquivOfIsCompl_symm_apply_fst_eq_zero
File: Mathlib/LinearAlgebra/Projection.lean

tactic: conv_rhs => rw [← (prodEquivOfIsCompl p q h).apply_symm_apply x]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ ((p.prodEquivOfIsCompl q h).symm x).1 = 0 ↔ x ∈ q
state_after: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ ((p.prodEquivOfIsCompl q h).symm x).1 = 0 ↔ (p.prodEquivOfIsCompl q h) ((p.prodEquivOfIsCompl q h).symm x) ∈ q

tactic: rw [coe_prodEquivOfIsCompl', Submodule.add_mem_iff_left _ (Submodule.coe_mem _),
  mem_right_iff_eq_zero_of_disjoint h.disjoint]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ ((p.prodEquivOfIsCompl q h).symm x).1 = 0 ↔ (p.prodEquivOfIsCompl q h) ((p.prodEquivOfIsCompl q h).symm x) ∈ q
state_after: no goals
Theorem: Real.Angle.abs_toReal_eq_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [abs_eq (div_nonneg Real.pi_pos.le two_pos.le), ← neg_div, toReal_eq_pi_div_two_iff,
  toReal_eq_neg_pi_div_two_iff]
state_before: θ : Angle
⊢ |θ.toReal| = π / 2 ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: no goals
Theorem: Set.SurjOn.bijOn_subset
File: Mathlib/Data/Set/Function.lean

tactic: refine h.invOn_invFunOn.bijOn ?_ (mapsTo_image _ _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ BijOn f (invFunOn f s '' t) t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ MapsTo f (invFunOn f s '' t) t

tactic: rintro _ ⟨y, hy, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ MapsTo f (invFunOn f s '' t) t
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
y : β
hy : y ∈ t
⊢ f (invFunOn f s y) ∈ t

tactic: rwa [h.rightInvOn_invFunOn hy]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
y : β
hy : y ∈ t
⊢ f (invFunOn f s y) ∈ t
state_after: no goals
Theorem: EuclideanDomain.dvd_div_of_mul_dvd
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
⊢ b ∣ c / a
state_after: case inl
R : Type u
inst✝ : EuclideanDomain R
b c : R
h : 0 * b ∣ c
⊢ b ∣ c / 0

case inr
R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a

tactic: rcases h with ⟨d, rfl⟩
state_before: case inr
R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a
state_after: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ b ∣ a * b * d / a

tactic: refine ⟨d, ?_⟩
state_before: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ b ∣ a * b * d / a
state_after: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ a * b * d / a = b * d

tactic: rw [mul_assoc, mul_div_cancel_left₀ _ ha]
state_before: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ a * b * d / a = b * d
state_after: no goals

tactic: simp only [div_zero, dvd_zero]
state_before: case inl
R : Type u
inst✝ : EuclideanDomain R
b c : R
h : 0 * b ∣ c
⊢ b ∣ c / 0
state_after: no goals
Theorem: MeasureTheory.IsFundamentalDomain.smul
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp [mul_assoc]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁹ : Group G
inst✝⁸ : Group H
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MulAction H β
inst✝⁴ : MeasurableSpace β
inst✝³ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α μ
h : IsFundamentalDomain G s μ
g g' : G
⊢ (fun g' => g * g' * g⁻¹) ((fun g' => g⁻¹ * g' * g) g') = g'
state_after: no goals

tactic: simp [mul_assoc]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁹ : Group G
inst✝⁸ : Group H
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MulAction H β
inst✝⁴ : MeasurableSpace β
inst✝³ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α μ
h : IsFundamentalDomain G s μ
g g' : G
⊢ (fun g' => g⁻¹ * g' * g) ((fun g' => g * g' * g⁻¹) g') = g'
state_after: no goals

tactic: simp [smul_smul, mul_assoc]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁹ : Group G
inst✝⁸ : Group H
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MulAction H β
inst✝⁴ : MeasurableSpace β
inst✝³ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α μ
h : IsFundamentalDomain G s μ
g g' : G
x : α
⊢ (MulAction.toPerm g)
      ((fun x =>
          { toFun := fun g' => g⁻¹ * g' * g, invFun := fun g' => g * g' * g⁻¹, left_inv := ⋯, right_inv := ⋯ } g' • x)
        x) =
    (fun x => g' • x) ((MulAction.toPerm g) x)
state_after: no goals
Theorem: div_eq_div_iff_div_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_iff_eq_mul, div_mul_eq_mul_div, div_eq_iff_eq_mul', mul_div_assoc]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a b c d : G
⊢ a / b = c / d ↔ a / c = b / d
state_after: no goals
Theorem: hasDerivAt_abs_rpow
File: Mathlib/Analysis/InnerProductSpace/NormPow.lean

tactic: simpa using hasDerivAt_norm_rpow x hp
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x p : ℝ
hp : 1 < p
⊢ HasDerivAt (fun x => |x| ^ p) (p * |x| ^ (p - 2) * x) x
state_after: no goals
Theorem: Real.lt_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sqrt_lt_sqrt_iff (sq_nonneg _), sqrt_sq hx]
state_before: x✝ y✝ x y : ℝ
hx : 0 ≤ x
⊢ x < √y ↔ x ^ 2 < y
state_after: no goals
Theorem: lt_mul_of_one_lt_left
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

tactic: simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
state_before: α : Type u_1
a b c d : α
inst✝³ : MulOneClass α
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : MulPosStrictMono α
hb : 0 < b
h : 1 < a
⊢ b < a * b
state_after: no goals
Theorem: Matrix.TransvectionStruct.sumInl_toMatrix_prod_mul
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: induction' L with t L IH
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
L : List (TransvectionStruct n R)
N : Matrix p p R
⊢ (List.map (toMatrix ∘ sumInl p) L).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix L).prod * M) 0 0 N
state_after: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
N : Matrix p p R
⊢ (List.map (toMatrix ∘ sumInl p) []).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix []).prod * M) 0 0 N

case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
N : Matrix p p R
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : (List.map (toMatrix ∘ sumInl p) L).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix L).prod * M) 0 0 N
⊢ (List.map (toMatrix ∘ sumInl p) (t :: L)).prod * fromBlocks M 0 0 N =
    fromBlocks ((List.map toMatrix (t :: L)).prod * M) 0 0 N

tactic: simp
state_before: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
N : Matrix p p R
⊢ (List.map (toMatrix ∘ sumInl p) []).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix []).prod * M) 0 0 N
state_after: no goals

tactic: simp [Matrix.mul_assoc, IH, toMatrix_sumInl, fromBlocks_multiply]
state_before: case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
N : Matrix p p R
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : (List.map (toMatrix ∘ sumInl p) L).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix L).prod * M) 0 0 N
⊢ (List.map (toMatrix ∘ sumInl p) (t :: L)).prod * fromBlocks M 0 0 N =
    fromBlocks ((List.map toMatrix (t :: L)).prod * M) 0 0 N
state_after: no goals
Theorem: Cardinal.power_le_max_power_one
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: by_cases ha : a = 0
state_before: α β : Type u
a b c : Cardinal.{u_1}
h : b ≤ c
⊢ a ^ b ≤ max (a ^ c) 1
state_after: case pos
α β : Type u
a b c : Cardinal.{u_1}
h : b ≤ c
ha : a = 0
⊢ a ^ b ≤ max (a ^ c) 1

case neg
α β : Type u
a b c : Cardinal.{u_1}
h : b ≤ c
ha : ¬a = 0
⊢ a ^ b ≤ max (a ^ c) 1

tactic: simp [ha, zero_power_le]
state_before: case pos
α β : Type u
a b c : Cardinal.{u_1}
h : b ≤ c
ha : a = 0
⊢ a ^ b ≤ max (a ^ c) 1
state_after: no goals

tactic: exact (power_le_power_left ha h).trans (le_max_left _ _)
state_before: case neg
α β : Type u
a b c : Cardinal.{u_1}
h : b ≤ c
ha : ¬a = 0
⊢ a ^ b ≤ max (a ^ c) 1
state_after: no goals
Theorem: Derivation.map_intCast
File: Mathlib/RingTheory/Derivation/Basic.lean

tactic: rw [← zsmul_one, D.map_smul_of_tower n, map_one_eq_zero, smul_zero]
state_before: R : Type u_1
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_3
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
n : ℤ
⊢ D ↑n = 0
state_after: no goals
Theorem: dvd_of_eq
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: rw [h]
state_before: α : Type u_1
inst✝ : Monoid α
a b c : α
m n : ℕ
h : a = b
⊢ a ∣ b
state_after: no goals
Theorem: Pi.Lex.noMaxOrder'
File: Mathlib/Order/PiLex.lean

tactic: let ⟨b, hb⟩ := exists_gt (a i)
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
⊢ ∃ b, a < b
state_after: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
b : β i
hb : a i < b
⊢ ∃ b, a < b

tactic: classical
exact ⟨Function.update a i b, i, fun j hj =>
  (Function.update_noteq hj.ne b a).symm, by rwa [Function.update_same i b]⟩
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
b : β i
hb : a i < b
⊢ ∃ b, a < b
state_after: no goals

tactic: exact ⟨Function.update a i b, i, fun j hj =>
  (Function.update_noteq hj.ne b a).symm, by rwa [Function.update_same i b]⟩
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
b : β i
hb : a i < b
⊢ ∃ b, a < b
state_after: no goals

tactic: rwa [Function.update_same i b]
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
b : β i
hb : a i < b
⊢ (fun x x_1 x_2 => x_1 < x_2) i (a i) (Function.update a i b i)
state_after: no goals
Theorem: Polynomial.cyclotomic_zero
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: simp only [cyclotomic, dif_pos]
state_before: R : Type u_1
inst✝ : Ring R
⊢ cyclotomic 0 R = 1
state_after: no goals
Theorem: EReal.openEmbedding_coe
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [range_coe_eq_Ioo, isOpen_Ioo]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ IsOpen (range Real.toEReal)
state_after: no goals
Theorem: pow_succ_padicValNat_not_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValNat_dvd_iff_le hn, not_le]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
⊢ ¬p ^ (padicValNat p n + 1) ∣ n
state_after: p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
⊢ padicValNat p n < padicValNat p n + 1

tactic: exact Nat.lt_succ_self _
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
⊢ padicValNat p n < padicValNat p n + 1
state_after: no goals
Theorem: Polynomial.toFinsupp_C_mul_X_pow
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [C_mul_X_pow_eq_monomial, toFinsupp_monomial]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
n : ℕ
⊢ (C a * X ^ n).toFinsupp = Finsupp.single n a
state_after: no goals
Theorem: Finset.sup_bot
File: Mathlib/Data/Finset/Lattice.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
s : Finset β
⊢ (s.sup fun x => ⊥) = ⊥
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ (∅.sup fun x => ⊥) = ⊥

case inr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
s : Finset β
hs : s.Nonempty
⊢ (s.sup fun x => ⊥) = ⊥

tactic: exact sup_empty
state_before: case inl
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ (∅.sup fun x => ⊥) = ⊥
state_after: no goals

tactic: exact sup_const hs _
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
s : Finset β
hs : s.Nonempty
⊢ (s.sup fun x => ⊥) = ⊥
state_after: no goals
Theorem: Complex.two_pi_I_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: norm_num [Real.pi_ne_zero, I_ne_zero]
state_before: ⊢ 2 * ↑π * I ≠ 0
state_after: no goals
Theorem: ProbabilityTheory.cgf_const'
File: Mathlib/Probability/Moments.lean

tactic: simp only [cgf, mgf_const']
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ cgf (fun x => c) μ t = log (μ Set.univ).toReal + t * c
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ log ((μ Set.univ).toReal * rexp (t * c)) = log (μ Set.univ).toReal + t * c

tactic: rw [log_mul _ (exp_pos _).ne']
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ log ((μ Set.univ).toReal * rexp (t * c)) = log (μ Set.univ).toReal + t * c
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ log (μ Set.univ).toReal + log (rexp (t * c)) = log (μ Set.univ).toReal + t * c

Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ (μ Set.univ).toReal ≠ 0

tactic: rw [log_exp _]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ log (μ Set.univ).toReal + log (rexp (t * c)) = log (μ Set.univ).toReal + t * c
state_after: no goals

tactic: rw [Ne, ENNReal.toReal_eq_zero_iff, Measure.measure_univ_eq_zero]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ (μ Set.univ).toReal ≠ 0
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ ¬(μ = 0 ∨ μ Set.univ = ⊤)

tactic: simp only [hμ, measure_ne_top μ Set.univ, or_self_iff, not_false_iff]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
hμ : μ ≠ 0
c : ℝ
⊢ ¬(μ = 0 ∨ μ Set.univ = ⊤)
state_after: no goals
Theorem: EuclideanGeometry.oangle_midpoint_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: by_cases h : p₁ = p₂
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ ∡ (midpoint ℝ p₁ p₂) p₂ p₃ = ∡ p₁ p₂ p₃
state_after: case pos
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : p₁ = p₂
⊢ ∡ (midpoint ℝ p₁ p₂) p₂ p₃ = ∡ p₁ p₂ p₃

case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ¬p₁ = p₂
⊢ ∡ (midpoint ℝ p₁ p₂) p₂ p₃ = ∡ p₁ p₂ p₃

tactic: exact (sbtw_midpoint_of_ne ℝ h).symm.oangle_eq_left
state_before: case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ¬p₁ = p₂
⊢ ∡ (midpoint ℝ p₁ p₂) p₂ p₃ = ∡ p₁ p₂ p₃
state_after: no goals

tactic: simp [h]
state_before: case pos
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : p₁ = p₂
⊢ ∡ (midpoint ℝ p₁ p₂) p₂ p₃ = ∡ p₁ p₂ p₃
state_after: no goals
Theorem: Subtype.coe_image_subset
File: Mathlib/Data/Set/Image.lean

tactic: rw [← yvaleq]
state_before: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ x ∈ s
state_after: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ ↑y ∈ s

tactic: exact y.property
state_before: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ ↑y ∈ s
state_after: no goals
Theorem: Subgroup.dvd_index_map
File: Mathlib/GroupTheory/Index.lean

tactic: rw [index_map, sup_of_le_left hf]
state_before: G : Type u_1
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_2
inst✝ : Group G'
f : G →* G'
hf : f.ker ≤ H
⊢ H.index ∣ (map f H).index
state_after: G : Type u_1
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_2
inst✝ : Group G'
f : G →* G'
hf : f.ker ≤ H
⊢ H.index ∣ H.index * f.range.index

tactic: apply dvd_mul_right
state_before: G : Type u_1
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_2
inst✝ : Group G'
f : G →* G'
hf : f.ker ≤ H
⊢ H.index ∣ H.index * f.range.index
state_after: no goals