ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.range_subtype_map
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
p : α → Prop
q : β → Prop
f : α → β
h : ∀ (x : α), p x → q (f x)
⊢ range (Subtype.map f h) = Subtype.val ⁻¹' (f '' {x | p x})
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
p : α → Prop
q : β → Prop
f : α → β
h : ∀ (x : α), p x → q (f x)
x : β
hx : q x
⊢ ⟨x, hx⟩ ∈ range (Subtype.map f h) ↔ ⟨x, hx⟩ ∈ Subtype.val ⁻¹' (f '' {x | p x})
tactic: ext ⟨x, hx⟩
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
p : α → Prop
q : β → Prop
f : α → β
h : ∀ (x : α), p x → q (f x)
x : β
hx : q x
⊢ ⟨x, hx⟩ ∈ range (Subtype.map f h) ↔ ⟨x, hx⟩ ∈ Subtype.val ⁻¹' (f '' {x | p x})
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
p : α → Prop
q : β → Prop
f : α → β
h : ∀ (x : α), p x → q (f x)
x : β
hx : q x
⊢ (∃ a, ∃ (h_1 : p a), ⟨f a, ⋯⟩ = ⟨x, hx⟩) ↔ ∃ x_1 ∈ {x | p x}, f x_1 = x
tactic: simp_rw [mem_preimage, mem_range, mem_image, Subtype.exists, Subtype.map]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
p : α → Prop
q : β → Prop
f : α → β
h : ∀ (x : α), p x → q (f x)
x : β
hx : q x
⊢ (∃ a, ∃ (h_1 : p a), ⟨f a, ⋯⟩ = ⟨x, hx⟩) ↔ ∃ x_1 ∈ {x | p x}, f x_1 = x
state_after: no goals
tactic: simp only [Subtype.mk.injEq, exists_prop, mem_setOf_eq]
Theorem: monovaryOn_inv_left
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ MonovaryOn f⁻¹ g s ↔ AntivaryOn f g s
state_after: no goals
tactic: simp [MonovaryOn, AntivaryOn]
Theorem: Complex.cos_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

Proof steps:
state_before: θ : ℂ
⊢ cos θ ≠ 0 ↔ ∀ (k : ℤ), θ ≠ (2 * ↑k + 1) * ↑π / 2
state_after: no goals
tactic: rw [← not_exists, not_iff_not, cos_eq_zero_iff]
Theorem: IsPGroup.card_orbit
File: Mathlib/GroupTheory/PGroup.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
tactic: let ϕ := orbitEquivQuotientStabilizer G a
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
this : Finite (G ⧸ stabilizer G a)
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
tactic: haveI := Finite.of_equiv (orbit G a) ϕ
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
this : Finite (G ⧸ stabilizer G a)
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
this✝ : Finite (G ⧸ stabilizer G a)
this : (stabilizer G a).FiniteIndex
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
tactic: haveI := (stabilizer G a).finiteIndex_of_finite_quotient
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
this✝ : Finite (G ⧸ stabilizer G a)
this : (stabilizer G a).FiniteIndex
⊢ ∃ n, Nat.card ↑(orbit G a) = p ^ n
state_after: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
this✝ : Finite (G ⧸ stabilizer G a)
this : (stabilizer G a).FiniteIndex
⊢ ∃ n, Nat.card (G ⧸ stabilizer G a) = p ^ n
tactic: rw [Nat.card_congr ϕ]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
a : α
inst✝ : Finite ↑(orbit G a)
ϕ : ↑(orbit G a) ≃ G ⧸ stabilizer G a := orbitEquivQuotientStabilizer G a
this✝ : Finite (G ⧸ stabilizer G a)
this : (stabilizer G a).FiniteIndex
⊢ ∃ n, Nat.card (G ⧸ stabilizer G a) = p ^ n
state_after: no goals
tactic: exact hG.index (stabilizer G a)
Theorem: lt_neg_iff_add_neg
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * b < b⁻¹ * b ↔ a * b < 1
state_after: no goals
tactic: rw [inv_mul_self]
Theorem: edist_pi_le_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝² : PseudoEMetricSpace α
π : β → Type u_2
inst✝¹ : Fintype β
inst✝ : (b : β) → EDist (π b)
f g : (b : β) → π b
d : ℝ≥0∞
⊢ (∀ b ∈ Finset.univ, edist (f b) (g b) ≤ d) ↔ ∀ (b : β), edist (f b) (g b) ≤ d
state_after: no goals
tactic: simp only [Finset.mem_univ, forall_const]
Theorem: intervalIntegral.inv_smul_integral_comp_div
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
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 c✝ d : ℝ
f : ℝ → E
c : ℝ
⊢ c⁻¹ • ∫ (x : ℝ) in a..b, f (x / c) = ∫ (x : ℝ) in a / c..b / c, f x
state_after: no goals
tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_div]
Theorem: compare_lt_iff_lt
File: Mathlib/Order/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.lt ↔ a < b
state_after: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ (if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) = Ordering.lt ↔ a < b
tactic: rw [LinearOrder.compare_eq_compareOfLessAndEq, compareOfLessAndEq]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ (if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) = Ordering.lt ↔ a < b
state_after: no goals
tactic: split_ifs <;> simp only [*, lt_irrefl]
Theorem: strictMono_dual_iff
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ StrictMono (⇑toDual ∘ f ∘ ⇑ofDual) ↔ StrictMono f
state_after: no goals
tactic: rw [strictMono_toDual_comp_iff, strictAnti_comp_ofDual_iff]
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫
      pullback.snd (fV 𝒰 f g j k) (fV 𝒰 f g j i) ≫
        pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) ≫ pullback.fst (𝒰.map j ≫ f) g =
    pullback.fst (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫ pullback.snd (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)
state_after: no goals
tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
    pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_fst,
    pullbackRightPullbackFstIso_hom_fst_assoc]
Theorem: CategoryTheory.Limits.colimit_ι_zero_cokernel_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C✝ : Type u
inst✝⁵ : Category.{v, u} C✝
inst✝⁴ : HasZeroMorphisms C✝
X✝ Y✝ : C✝
f✝ : X✝ ⟶ Y✝
inst✝³ : HasCokernel f✝
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : f ≫ g = 0
inst✝ : HasCokernel f
⊢ colimit.ι (parallelPair f 0) zero ≫ cokernel.desc f g h = 0
state_after: C✝ : Type u
inst✝⁵ : Category.{v, u} C✝
inst✝⁴ : HasZeroMorphisms C✝
X✝ Y✝ : C✝
f✝ : X✝ ⟶ Y✝
inst✝³ : HasCokernel f✝
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : f ≫ g = 0
inst✝ : HasCokernel f
⊢ ((parallelPair f 0).map WalkingParallelPairHom.left ≫ colimit.ι (parallelPair f 0) one) ≫ cokernel.desc f g h = 0
tactic: rw [(colimit.w (parallelPair f 0) WalkingParallelPairHom.left).symm]
state_before: C✝ : Type u
inst✝⁵ : Category.{v, u} C✝
inst✝⁴ : HasZeroMorphisms C✝
X✝ Y✝ : C✝
f✝ : X✝ ⟶ Y✝
inst✝³ : HasCokernel f✝
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : f ≫ g = 0
inst✝ : HasCokernel f
⊢ ((parallelPair f 0).map WalkingParallelPairHom.left ≫ colimit.ι (parallelPair f 0) one) ≫ cokernel.desc f g h = 0
state_after: no goals
tactic: aesop_cat
Theorem: Function.Injective.sOppSide_map_iff
File: Mathlib/Analysis/Convex/Side.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
hf : Function.Injective ⇑f
⊢ (map f s).SOppSide (f x) (f y) ↔ s.SOppSide x y
state_after: no goals
tactic: simp_rw [SOppSide, hf.wOppSide_map_iff, mem_map_iff_mem_of_injective hf]
Theorem: Matrix.diagonal_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
⊢ diagonal v i ⬝ᵥ w = v i * w i
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → diagonal v i j * w j = 0
⊢ diagonal v i ⬝ᵥ w = v i * w i
tactic: have : ∀ j ≠ i, diagonal v i j * w j = 0 := fun j hij => by
    simp [diagonal_apply_ne' _ hij]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → diagonal v i j * w j = 0
⊢ diagonal v i ⬝ᵥ w = v i * w i
state_after: no goals
tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
Theorem: Bool.not_eq_false_eq_eq_true
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: a : Bool
⊢ ((!a) = false) = (a = true)
state_after: no goals
tactic: cases a <;> simp
Theorem: nhds_basis_opens
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
⊢ (𝓝 x).HasBasis (fun s => x ∈ s ∧ IsOpen s) fun s => s
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
⊢ (⨅ s ∈ {s | x ∈ s ∧ IsOpen s}, 𝓟 s).HasBasis (fun s => x ∈ s ∧ IsOpen s) fun s => s
tactic: rw [nhds_def]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
⊢ (⨅ s ∈ {s | x ∈ s ∧ IsOpen s}, 𝓟 s).HasBasis (fun s => x ∈ s ∧ IsOpen s) fun s => s
state_after: no goals
tactic: exact hasBasis_biInf_principal
    (fun s ⟨has, hs⟩ t ⟨hat, ht⟩ =>
      ⟨s ∩ t, ⟨⟨has, hat⟩, IsOpen.inter hs ht⟩, ⟨inter_subset_left, inter_subset_right⟩⟩)
    ⟨univ, ⟨mem_univ x, isOpen_univ⟩⟩
Theorem: MonoidAlgebra.induction_on
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
⊢ p f
state_after: case refine_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
⊢ p 0

case refine_2
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
g : G
r : k
⊢ p (Finsupp.single g r)
tactic: refine Finsupp.induction_linear f ?_ (fun f g hf hg => hadd f g hf hg) fun g r => ?_
Theorem: subset_balancedCore
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
⊢ s ⊆ balancedCore 𝕜 t
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
⊢ s ⊆ ⋂ r, ⋂ (_ : 1 ≤ ‖r‖), r • t
tactic: rw [balancedCore_eq_iInter ht]
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
⊢ s ⊆ ⋂ r, ⋂ (_ : 1 ≤ ‖r‖), r • t
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ s ⊆ a • t
tactic: refine subset_iInter₂ fun a ha => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ s ⊆ a • t
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ a • a⁻¹ • s ⊆ a • t
tactic: rw [← smul_inv_smul₀ (norm_pos_iff.mp <| zero_lt_one.trans_le ha) s]
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ a • a⁻¹ • s ⊆ a • t
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ ‖a⁻¹‖ ≤ 1
tactic: refine smul_set_mono (hst _ ?_)
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ ‖a⁻¹‖ ≤ 1
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ ‖a‖⁻¹ ≤ 1
tactic: rw [norm_inv]
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ ‖a‖⁻¹ ≤ 1
state_after: no goals
tactic: exact inv_le_one ha
Theorem: LocallyFinite.exists_finset_nhd_support_subset
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
ι : Type u_10
inst✝¹ : TopologicalSpace X
U : ι → Set X
inst✝ : One R
f : ι → X → R
hlf : LocallyFinite fun i => mulSupport (f i)
hso : ∀ (i : ι), mulTSupport (f i) ⊆ U i
ho : ∀ (i : ι), IsOpen (U i)
x : X
⊢ ∃ is, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (mulSupport fun i => f i z) ⊆ ↑is
state_after: case intro.intro
X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
ι : Type u_10
inst✝¹ : TopologicalSpace X
U : ι → Set X
inst✝ : One R
f : ι → X → R
hlf : LocallyFinite fun i => mulSupport (f i)
hso : ∀ (i : ι), mulTSupport (f i) ⊆ U i
ho : ∀ (i : ι), IsOpen (U i)
x : X
n : Set X
hn : n ∈ 𝓝 x
hnf : {i | ((fun i => mulSupport (f i)) i ∩ n).Nonempty}.Finite
⊢ ∃ is, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (mulSupport fun i => f i z) ⊆ ↑is
tactic: obtain ⟨n, hn, hnf⟩ := hlf x
Theorem: CategoryTheory.Bicategory.Adjunction.comp_left_triangle_aux
File: Mathlib/CategoryTheory/Bicategory/Adjunction.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
g : b ⟶ a
f₁ : a ⟶ b
g₁ : b ⟶ a
f₂ : b ⟶ c
g₂ : c ⟶ b
adj₁ : f₁ ⊣ g₁
adj₂ : f₂ ⊣ g₂
⊢ leftZigzag (adj₁.compUnit adj₂) (adj₁.compCounit adj₂) = (λ_ (f₁ ≫ f₂)).hom ≫ (ρ_ (f₁ ≫ f₂)).inv
state_after: no goals
tactic: calc
    _ = 𝟙 _ ⊗≫
          adj₁.unit ▷ (f₁ ≫ f₂) ⊗≫
            f₁ ◁ (adj₂.unit ▷ (g₁ ≫ f₁) ≫ (f₂ ≫ g₂) ◁ adj₁.counit) ▷ f₂ ⊗≫
              (f₁ ≫ f₂) ◁ adj₂.counit ⊗≫ 𝟙 _ := by
      simp [bicategoricalComp]; coherence
    _ = 𝟙 _ ⊗≫
          (leftZigzag adj₁.unit adj₁.counit) ▷ f₂ ⊗≫
            f₁ ◁ (leftZigzag adj₂.unit adj₂.counit) ⊗≫ 𝟙 _ := by
      rw [← whisker_exchange]; simp [bicategoricalComp]; coherence
    _ = _ := by
      simp_rw [left_triangle]; simp [bicategoricalComp]
Theorem: RatFunc.coe_coe
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
P : F[X]
⊢ (ofPowerSeries ℤ F) ↑P = ↑↑P
state_after: no goals
tactic: simp only [coePolynomial, coe_def, AlgHom.commutes, algebraMap_hahnSeries_apply]
Theorem: PowerSeries.coeff_zero_mul_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (coeff R 0) (φ * X) = 0
state_after: no goals
tactic: simp
Theorem: ENNReal.smul_toNNReal
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q a : ℝ≥0
b : ℝ≥0∞
⊢ (a • b).toNNReal = a * b.toNNReal
state_after: a✝ b✝ c d : ℝ≥0∞
r p q a : ℝ≥0
b : ℝ≥0∞
⊢ (↑a * b).toNNReal = a * b.toNNReal
tactic: change ((a : ℝ≥0∞) * b).toNNReal = a * b.toNNReal
state_before: a✝ b✝ c d : ℝ≥0∞
r p q a : ℝ≥0
b : ℝ≥0∞
⊢ (↑a * b).toNNReal = a * b.toNNReal
state_after: no goals
tactic: simp only [ENNReal.toNNReal_mul, ENNReal.toNNReal_coe]
Theorem: Ordnode.Raised.dist_le
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
n m : ℕ
H : Raised n m
⊢ n.dist m ≤ 1
state_after: case intro
α : Type u_1
n m : ℕ
H : Raised n m
H1 : n ≤ m
H2 : m ≤ n + 1
⊢ n.dist m ≤ 1
tactic: cases' raised_iff.1 H with H1 H2
state_before: case intro
α : Type u_1
n m : ℕ
H : Raised n m
H1 : n ≤ m
H2 : m ≤ n + 1
⊢ n.dist m ≤ 1
state_after: no goals
tactic: rwa [Nat.dist_eq_sub_of_le H1, tsub_le_iff_left]
Theorem: Finset.prod_one_sub_ordered
File: Mathlib/Algebra/BigOperators/Ring.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i : ι
a : α
f✝ g : ι → α
inst✝¹ : CommRing α
inst✝ : LinearOrder ι
s : Finset ι
f : ι → α
⊢ ∏ i ∈ s, (1 - f i) = 1 - ∑ i ∈ s, f i * ∏ j ∈ filter (fun x => x < i) s, (1 - f j)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i : ι
a : α
f✝ g : ι → α
inst✝¹ : CommRing α
inst✝ : LinearOrder ι
s : Finset ι
f : ι → α
⊢ ∏ i ∈ s, 1 - ∑ i ∈ s, (f i * ∏ j ∈ filter (fun x => x < i) s, (1 - f j)) * ∏ j ∈ filter (fun j => i < j) s, 1 =
    1 - ∑ i ∈ s, f i * ∏ j ∈ filter (fun x => x < i) s, (1 - f j)
tactic: rw [prod_sub_ordered]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i : ι
a : α
f✝ g : ι → α
inst✝¹ : CommRing α
inst✝ : LinearOrder ι
s : Finset ι
f : ι → α
⊢ ∏ i ∈ s, 1 - ∑ i ∈ s, (f i * ∏ j ∈ filter (fun x => x < i) s, (1 - f j)) * ∏ j ∈ filter (fun j => i < j) s, 1 =
    1 - ∑ i ∈ s, f i * ∏ j ∈ filter (fun x => x < i) s, (1 - f j)
state_after: no goals
tactic: simp
Theorem: sameRay_iff_of_norm_eq
File: Mathlib/Analysis/Normed/Module/Ray.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
h : ‖x‖ = ‖y‖
⊢ SameRay ℝ x y ↔ x = y
state_after: case inl
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
h : ‖x‖ = ‖0‖
⊢ SameRay ℝ x 0 ↔ x = 0

case inr
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
h : ‖x‖ = ‖y‖
hy : y ≠ 0
⊢ SameRay ℝ x y ↔ x = y
tactic: obtain rfl | hy := eq_or_ne y 0
Theorem: Ordinal.toPGame_leftMoves
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ o.toPGame.LeftMoves = (Quotient.out o).α
state_after: no goals
tactic: rw [toPGame, LeftMoves]