ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.infsep_pair_le_toReal_inf
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hxy : x ≠ y
⊢ {x, y}.infsep ≤ (edist x y ⊓ edist y x).toReal
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hxy : x ≠ y
⊢ (edist x y ⊓ edist y x).toReal ≤ (edist x y ⊓ edist y x).toReal
tactic: simp_rw [infsep, einfsep_pair_eq_inf hxy]
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hxy : x ≠ y
⊢ (edist x y ⊓ edist y x).toReal ≤ (edist x y ⊓ edist y x).toReal
state_after: no goals
tactic: simp
Theorem: AlgebraicGeometry.Scheme.Hom.appLE_map
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: X Y : Scheme
f : X.Hom Y
U U' : Y.Opens
V V' : X.Opens
e : V ≤ f ⁻¹ᵁ U
i : op V ⟶ op V'
⊢ f.appLE U V e ≫ X.presheaf.map i = f.appLE U V' ⋯
state_after: X Y : Scheme
f : X.Hom Y
U U' : Y.Opens
V V' : X.Opens
e : V ≤ f ⁻¹ᵁ U
i : op V ⟶ op V'
⊢ f.app U ≫ X.presheaf.map ((homOfLE e).op ≫ i) = f.appLE U V' ⋯
tactic: rw [Hom.appLE, Category.assoc, ← Functor.map_comp]
state_before: X Y : Scheme
f : X.Hom Y
U U' : Y.Opens
V V' : X.Opens
e : V ≤ f ⁻¹ᵁ U
i : op V ⟶ op V'
⊢ f.app U ≫ X.presheaf.map ((homOfLE e).op ≫ i) = f.appLE U V' ⋯
state_after: no goals
tactic: rfl
Theorem: neg_one_zsmul_add
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b✝ c d a b : α
⊢ (a * b) ^ (-1) = b ^ (-1) * a ^ (-1)
state_after: no goals
tactic: simp only [zpow_neg, zpow_one, mul_inv_rev]
Theorem: EuclideanGeometry.oangle_left_eq_arctan_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
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
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ ∡ p₃ p₁ p₂ = ↑(Real.arctan (dist p₃ p₂ / dist p₁ p₂))
state_after: 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₂ p₃ = ↑(π / 2)
hs : (∡ p₃ p₁ p₂).sign = 1
⊢ ∡ p₃ p₁ p₂ = ↑(Real.arctan (dist p₃ p₂ / dist p₁ p₂))
tactic: have hs : (∡ p₃ p₁ p₂).sign = 1 := by rw [← oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
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
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₃ p₁ p₂).sign = 1
⊢ ∡ p₃ p₁ p₂ = ↑(Real.arctan (dist p₃ p₂ / dist p₁ p₂))
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs, angle_comm,
    angle_eq_arctan_of_angle_eq_pi_div_two (angle_rev_eq_pi_div_two_of_oangle_eq_pi_div_two h)
      (left_ne_of_oangle_eq_pi_div_two h)]
Theorem: LocalizedModule.mul_by_divBy
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
p : LocalizedModule S M
m : M
t : ↥S
⊢ ((algebraMap R (Module.End R (LocalizedModule S M))) ↑s) ((divBy s) (mk m t)) = mk m t
state_after: no goals
tactic: rw [divBy_apply, Module.algebraMap_end_apply, LocalizedModule.liftOn_mk, smul'_mk,
      ← Submonoid.smul_def, mk_cancel_common_right _ s]
Theorem: Algebra.Presentation.localizationAway_rels
File: Mathlib/RingTheory/Presentation.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Ideal.span (Set.range fun x => C r * X () - 1) = (Generators.localizationAway r).ker
state_after: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Ideal.span {C r * X () - 1} = (Generators.localizationAway r).ker
tactic: simp only [Generators.localizationAway_vars, Set.range_const]
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Ideal.span {C r * X () - 1} = (Generators.localizationAway r).ker
state_after: no goals
tactic: apply span_range_relation_eq_ker_localizationAway r
Theorem: IsAddMonoidHom.comp
File: Mathlib/Deprecated/Group.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
f : α → β
hf : IsMonoidHom f
γ : Type u_1
inst✝ : MulOneClass γ
g : β → γ
hg : IsMonoidHom g
⊢ g (f 1) = 1
state_after: no goals
tactic: rw [hf.map_one, hg.map_one]
Theorem: Matrix.row_eq_zero_of_commute_stdBasisMatrix
File: Mathlib/Data/Matrix/Basis.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
i j k : n
M : Matrix n n α
hM : Commute (stdBasisMatrix i j 1) M
hkj : k ≠ j
⊢ M j k = 0
state_after: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
i j k : n
M : Matrix n n α
hM : Commute (stdBasisMatrix i j 1) M
hkj : k ≠ j
this : (stdBasisMatrix i j 1 * M) i k = (M * stdBasisMatrix i j 1) i k
⊢ M j k = 0
tactic: have := ext_iff.mpr hM i k
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : Fintype n
i j k : n
M : Matrix n n α
hM : Commute (stdBasisMatrix i j 1) M
hkj : k ≠ j
this : (stdBasisMatrix i j 1 * M) i k = (M * stdBasisMatrix i j 1) i k
⊢ M j k = 0
state_after: no goals
tactic: aesop
Theorem: mulIndicator_cthickening_eventually_eq_mulIndicator_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : PseudoEMetricSpace α
β : Type u_2
inst✝ : One β
f : α → β
E : Set α
x : α
⊢ ∀ᶠ (δ : ℝ) in 𝓝 0, (cthickening δ E).mulIndicator f x = (closure E).mulIndicator f x
state_after: case pos
α : Type u_1
inst✝¹ : PseudoEMetricSpace α
β : Type u_2
inst✝ : One β
f : α → β
E : Set α
x : α
x_mem_closure : x ∈ closure E
⊢ ∀ᶠ (δ : ℝ) in 𝓝 0, (cthickening δ E).mulIndicator f x = (closure E).mulIndicator f x

case neg
α : Type u_1
inst✝¹ : PseudoEMetricSpace α
β : Type u_2
inst✝ : One β
f : α → β
E : Set α
x : α
x_mem_closure : x ∉ closure E
⊢ ∀ᶠ (δ : ℝ) in 𝓝 0, (cthickening δ E).mulIndicator f x = (closure E).mulIndicator f x
tactic: by_cases x_mem_closure : x ∈ closure E
Theorem: Matroid.ofExistsFiniteBase_E
File: Mathlib/Data/Matroid/IndepAxioms.lean

Proof steps:
state_before: α : Type u_1
I B X E : Set α
Base : Set α → Prop
exists_finite_base : ∃ B, Base B ∧ B.Finite
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
⊢ ∃ B, Base B
state_after: case intro
α : Type u_1
I B✝ X E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
h : Base B ∧ B.Finite
⊢ ∃ B, Base B
tactic: obtain ⟨B,h⟩ := exists_finite_base
state_before: case intro
α : Type u_1
I B✝ X E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
h : Base B ∧ B.Finite
⊢ ∃ B, Base B
state_after: no goals
tactic: exact ⟨B, h.1⟩
state_before: α : Type u_1
I B X E : Set α
Base : Set α → Prop
exists_finite_base : ∃ B, Base B ∧ B.Finite
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
⊢ ∀ X ⊆ E, ExistsMaximalSubsetProperty (fun x => ∃ B, Base B ∧ x ⊆ B) X
state_after: case intro.intro
α : Type u_1
I B✝ X E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
hB : Base B
hfin : B.Finite
⊢ ∀ X ⊆ E, ExistsMaximalSubsetProperty (fun x => ∃ B, Base B ∧ x ⊆ B) X
tactic: obtain ⟨B, hB, hfin⟩ := exists_finite_base
state_before: case intro.intro
α : Type u_1
I B✝ X E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
hB : Base B
hfin : B.Finite
⊢ ∀ X ⊆ E, ExistsMaximalSubsetProperty (fun x => ∃ B, Base B ∧ x ⊆ B) X
state_after: case intro.intro
α : Type u_1
I B✝ X✝ E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
hB : Base B
hfin : B.Finite
X : Set α
x✝¹ : X ⊆ E
Y : Set α
x✝ : ∃ B, Base B ∧ Y ⊆ B
B' : Set α
hB' : Base B'
hYB' : Y ⊆ B'
⊢ Y.encard ≤ ↑B.ncard
tactic: refine fun X _ ↦ Matroid.existsMaximalSubsetProperty_of_bdd
      ⟨B.ncard, fun Y ⟨B', hB', hYB'⟩ ↦ ?_⟩ X
state_before: case intro.intro
α : Type u_1
I B✝ X✝ E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
hB : Base B
hfin : B.Finite
X : Set α
x✝¹ : X ⊆ E
Y : Set α
x✝ : ∃ B, Base B ∧ Y ⊆ B
B' : Set α
hB' : Base B'
hYB' : Y ⊆ B'
⊢ Y.encard ≤ ↑B.ncard
state_after: case intro.intro
α : Type u_1
I B✝ X✝ E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
hB : Base B
hfin : B.Finite
X : Set α
x✝¹ : X ⊆ E
Y : Set α
x✝ : ∃ B, Base B ∧ Y ⊆ B
B' : Set α
hB' : Base B'
hYB' : Y ⊆ B'
⊢ Y.encard ≤ B'.encard
tactic: rw [hfin.cast_ncard_eq, base_exchange.encard_base_eq hB hB']
state_before: case intro.intro
α : Type u_1
I B✝ X✝ E : Set α
Base : Set α → Prop
base_exchange : ExchangeProperty Base
subset_ground : ∀ (B : Set α), Base B → B ⊆ E
B : Set α
hB : Base B
hfin : B.Finite
X : Set α
x✝¹ : X ⊆ E
Y : Set α
x✝ : ∃ B, Base B ∧ Y ⊆ B
B' : Set α
hB' : Base B'
hYB' : Y ⊆ B'
⊢ Y.encard ≤ B'.encard
state_after: no goals
tactic: exact encard_mono hYB'
Theorem: Complex.log_one
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: ⊢ log 1 = 0
state_after: no goals
tactic: simp [log]
Theorem: ProbabilityTheory.Kernel.lintegral_fst
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
κ : Kernel α (β × γ)
a : α
g : β → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : β), g c ∂κ.fst a = ∫⁻ (bc : β × γ), g bc.1 ∂κ a
state_after: no goals
tactic: rw [fst, lintegral_map _ measurable_fst a hg]
Theorem: partialSups_iff_forall
File: Mathlib/Order/PartialSups.lean

Proof steps:
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
p : α → Prop
hp : ∀ {a b : α}, p (a ⊔ b) ↔ p a ∧ p b
⊢ p ((partialSups f) 0) ↔ ∀ k ≤ 0, p (f k)
state_after: no goals
tactic: simp
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
p : α → Prop
hp : ∀ {a b : α}, p (a ⊔ b) ↔ p a ∧ p b
n : ℕ
⊢ p ((partialSups f) (n + 1)) ↔ ∀ k ≤ n + 1, p (f k)
state_after: no goals
tactic: simp [hp, partialSups_iff_forall, ← Nat.lt_succ_iff, ← Nat.forall_lt_succ]
Theorem: continuous_pi_iff
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
⊢ Continuous f ↔ ∀ (i : ι), Continuous fun a => f a i
state_after: no goals
tactic: simp only [continuous_iInf_rng, continuous_induced_rng, comp]
Theorem: PadicInt.zmod_congr_of_sub_mem_span_aux
File: Mathlib/NumberTheory/Padics/RingHoms.lean

Proof steps:
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : x - ↑a ∈ Ideal.span {↑p ^ n}
hb : x - ↑b ∈ Ideal.span {↑p ^ n}
⊢ ↑a = ↑b
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ x - ↑a
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑a = ↑b
tactic: rw [Ideal.mem_span_singleton] at ha hb
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ x - ↑a
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑a = ↑b
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ x - ↑a
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑p ^ n ∣ a - b
tactic: rw [← sub_eq_zero, ← Int.cast_sub, ZMod.intCast_zmod_eq_zero_iff_dvd, Int.natCast_pow]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ x - ↑a
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑p ^ n ∣ a - b
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ ↑a - x
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑p ^ n ∣ a - b
tactic: rw [← dvd_neg, neg_sub] at ha
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ ↑a - x
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑p ^ n ∣ a - b
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ ↑a - x
hb : ↑p ^ n ∣ x - ↑b
this : ↑p ^ n ∣ ↑a - x + (x - ↑b)
⊢ ↑p ^ n ∣ a - b
tactic: have := dvd_add ha hb
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ ↑a - x
hb : ↑p ^ n ∣ x - ↑b
this : ↑p ^ n ∣ ↑a - x + (x - ↑b)
⊢ ↑p ^ n ∣ a - b
state_after: no goals
tactic: rwa [sub_eq_add_neg, sub_eq_add_neg, add_assoc, neg_add_cancel_left, ← sub_eq_add_neg, ←
    Int.cast_sub, pow_p_dvd_int_iff] at this
Theorem: separableClosure.eq_bot_iff
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : Algebra.IsAlgebraic F E
h : separableClosure F E = ⊥
x : E
hs : IsSeparable F x
⊢ x ∈ (algebraMap F E).range
state_after: no goals
tactic: simpa only [h] using mem_separableClosure_iff.2 hs
Theorem: dist_self_mul_left
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist (a * b) a = ‖b‖
state_after: no goals
tactic: rw [dist_comm, dist_self_mul_right]
Theorem: Matroid.basis_iff
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.Basis I X ↔ M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J
state_after: no goals
tactic: rw [basis_iff', and_iff_left hX]
Theorem: Subsemiring.mem_sSup_of_directedOn
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S✝
inst✝ : NonAssocSemiring T
S : Set (Subsemiring R)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
state_after: R : Type u
S✝ : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S✝
inst✝ : NonAssocSemiring T
S : Set (Subsemiring R)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
tactic: haveI : Nonempty S := Sne.to_subtype
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S✝
inst✝ : NonAssocSemiring T
S : Set (Subsemiring R)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
state_after: no goals
tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk,
    exists_prop]
Theorem: MeasureTheory.Integrable.norm_integral_condexpKernel
File: Mathlib/Probability/Kernel/Condexp.lean

Proof steps:
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
μ : Measure Ω
inst✝² : IsFiniteMeasure μ
inst✝¹ : NormedAddCommGroup F
f : Ω → F
inst✝ : NormedSpace ℝ F
hf_int : Integrable f μ
⊢ Integrable (fun ω => ‖∫ (y : Ω), f y ∂(condexpKernel μ m) ω‖) μ
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
μ : Measure Ω
inst✝² : IsFiniteMeasure μ
inst✝¹ : NormedAddCommGroup F
f : Ω → F
inst✝ : NormedSpace ℝ F
hf_int : Integrable f μ
⊢ Integrable (fun ω => ‖∫ (y : Ω), f y ∂((condDistrib id id μ).comap id ⋯) ω‖) μ
tactic: rw [condexpKernel]
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
μ : Measure Ω
inst✝² : IsFiniteMeasure μ
inst✝¹ : NormedAddCommGroup F
f : Ω → F
inst✝ : NormedSpace ℝ F
hf_int : Integrable f μ
⊢ Integrable (fun ω => ‖∫ (y : Ω), f y ∂((condDistrib id id μ).comap id ⋯) ω‖) μ
state_after: no goals
tactic: convert Integrable.norm_integral_condDistrib
    (aemeasurable_id'' μ (inf_le_right : m ⊓ mΩ ≤ mΩ)) aemeasurable_id
    (hf_int.comp_snd_map_prod_id (inf_le_right : m ⊓ mΩ ≤ mΩ)) using 1
Theorem: Order.sequenceOfCofinals.encode_mem
File: Mathlib/Order/Ideal.lean

Proof steps:
state_before: P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
i : ι
⊢ sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i
state_after: P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
i : ι
⊢ (match Encodable.decode (Encodable.encode i) with
    | none => sequenceOfCofinals p 𝒟 (Encodable.encode i)
    | some i_1 => (𝒟 i_1).above (sequenceOfCofinals p 𝒟 (Encodable.encode i))) ∈
    𝒟 i
tactic: dsimp only [sequenceOfCofinals, Nat.add]
state_before: P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
i : ι
⊢ (match Encodable.decode (Encodable.encode i) with
    | none => sequenceOfCofinals p 𝒟 (Encodable.encode i)
    | some i_1 => (𝒟 i_1).above (sequenceOfCofinals p 𝒟 (Encodable.encode i))) ∈
    𝒟 i
state_after: P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
i : ι
⊢ (match some i with
    | none => sequenceOfCofinals p 𝒟 (Encodable.encode i)
    | some i_1 => (𝒟 i_1).above (sequenceOfCofinals p 𝒟 (Encodable.encode i))) ∈
    𝒟 i
tactic: rw [Encodable.encodek]
state_before: P : Type u_1
inst✝¹ : Preorder P
p : P
ι : Type u_2
inst✝ : Encodable ι
𝒟 : ι → Cofinal P
i : ι
⊢ (match some i with
    | none => sequenceOfCofinals p 𝒟 (Encodable.encode i)
    | some i_1 => (𝒟 i_1).above (sequenceOfCofinals p 𝒟 (Encodable.encode i))) ∈
    𝒟 i
state_after: no goals
tactic: apply Cofinal.above_mem
Theorem: balanced_iff_closedBall_smul
File: Mathlib/Analysis/LocallyConvex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t u v A B : Set E
⊢ Balanced 𝕜 s ↔ Metric.closedBall 0 1 • s ⊆ s
state_after: no goals
tactic: simp [balanced_iff_smul_mem, smul_subset_iff]
Theorem: Set.strictMonoOn_projIci
File: Mathlib/Order/Interval/Set/ProjIcc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ x : α
hx : x ∈ Ici a
y : α
hy : y ∈ Ici a
hxy : x < y
⊢ projIci a x < projIci a y
state_after: no goals
tactic: simpa only [projIci_of_mem, hx, hy]
Theorem: Polynomial.support_smul
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
⊢ (r • p).support ⊆ p.support
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
i : ℕ
hi : i ∈ (r • p).support
⊢ i ∈ p.support
tactic: intro i hi
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
i : ℕ
hi : i ∈ (r • p).support
⊢ i ∈ p.support
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
i : ℕ
hi : ¬r • p.coeff i = 0
⊢ ¬p.coeff i = 0
tactic: simp? [mem_support_iff] at hi ⊢ says simp only [mem_support_iff, coeff_smul, ne_eq] at hi ⊢
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
i : ℕ
hi : ¬r • p.coeff i = 0
⊢ ¬p.coeff i = 0
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
i : ℕ
hi : p.coeff i = 0
⊢ r • p.coeff i = 0
tactic: contrapose! hi
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : SMulZeroClass S R
r : S
p : R[X]
i : ℕ
hi : p.coeff i = 0
⊢ r • p.coeff i = 0
state_after: no goals
tactic: simp [hi]
Theorem: multiset_prod_mem
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset M
hm : ∀ a ∈ m, a ∈ S
⊢ m.prod ∈ S
state_after: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ (Multiset.map Subtype.val m).prod ∈ S
tactic: lift m to Multiset S using hm
state_before: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ (Multiset.map Subtype.val m).prod ∈ S
state_after: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ ↑m.prod ∈ S
tactic: rw [← coe_multiset_prod]
state_before: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ ↑m.prod ∈ S
state_after: no goals
tactic: exact m.prod.coe_prop
Theorem: Set.Ioo_add_bij
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioo a b) (Ioo (a + d) (b + d))
state_after: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioi a ∩ Iio b) (Ioi (a + d) ∩ Iio (b + d))
tactic: rw [← Ioi_inter_Iio, ← Ioi_inter_Iio]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioi a ∩ Iio b) (Ioi (a + d) ∩ Iio (b + d))
state_after: no goals
tactic: exact
    (Ioi_add_bij a d).inter_mapsTo (fun x hx => add_lt_add_right hx _) fun x hx =>
      lt_of_add_lt_add_right hx.2
Theorem: Complex.ofReal_arctan
File: Mathlib/Analysis/SpecialFunctions/Complex/Arctan.lean

Proof steps:
state_before: x : ℝ
⊢ ↑(Real.arctan x) = (↑x).arctan
state_after: x : ℝ
⊢ ↑(Real.arctan x) = (↑(Real.tan (Real.arctan x))).arctan
tactic: conv_rhs => rw [← Real.tan_arctan x]
state_before: x : ℝ
⊢ ↑(Real.arctan x) = (↑(Real.tan (Real.arctan x))).arctan
state_after: case h₀
x : ℝ
⊢ ↑(Real.arctan x) ≠ ↑π / 2

case h₁
x : ℝ
⊢ -(π / 2) < (↑(Real.arctan x)).re

case h₂
x : ℝ
⊢ (↑(Real.arctan x)).re ≤ π / 2
tactic: rw [ofReal_tan, arctan_tan]
state_before: case h₀
x : ℝ
⊢ ↑(Real.arctan x) ≠ ↑π / 2

case h₁
x : ℝ
⊢ -(π / 2) < (↑(Real.arctan x)).re

case h₂
x : ℝ
⊢ (↑(Real.arctan x)).re ≤ π / 2
state_after: case h₀
x : ℝ
⊢ ¬Real.arctan x = π / 2

case h₁
x : ℝ
⊢ -(π / 2) < Real.arctan x

case h₂
x : ℝ
⊢ Real.arctan x ≤ π / 2
tactic: all_goals norm_cast