tasksource/leandojo huggingface dataset:
Theorem: AffineMap.image_convexHull
File: Mathlib/Analysis/Convex/Hull.lean

tactic: apply Set.Subset.antisymm
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
f : E →ᵃ[𝕜] F
⊢ ↑f '' ↑(convexHull 𝕜).toOrderHom s = ↑(convexHull 𝕜).toOrderHom (↑f '' s)

tactic: rw [Set.image_subset_iff]
state_before: case h₁
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
f : E →ᵃ[𝕜] F
⊢ ↑f '' ↑(convexHull 𝕜).toOrderHom s ⊆ ↑(convexHull 𝕜).toOrderHom (↑f '' s)

tactic: refine' convexHull_min _ ((convex_convexHull 𝕜 (f '' s)).affine_preimage f)
state_before: case h₁
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
f : E →ᵃ[𝕜] F
⊢ ↑(convexHull 𝕜).toOrderHom s ⊆ ↑f ⁻¹' ↑(convexHull 𝕜).toOrderHom (↑f '' s)

tactic: rw [← Set.image_subset_iff]
state_before: case h₁
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
f : E →ᵃ[𝕜] F
⊢ s ⊆ ↑f ⁻¹' ↑(convexHull 𝕜).toOrderHom (↑f '' s)

tactic: exact subset_convexHull 𝕜 (f '' s)
state_before: case h₁
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
f : E →ᵃ[𝕜] F
⊢ ↑f '' s ⊆ ↑(convexHull 𝕜).toOrderHom (↑f '' s)

tactic: exact convexHull_min (Set.image_subset _ (subset_convexHull 𝕜 s))
  ((convex_convexHull 𝕜 s).affine_image f)
state_before: case h₂
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
f : E →ᵃ[𝕜] F
⊢ ↑(convexHull 𝕜).toOrderHom (↑f '' s) ⊆ ↑f '' ↑(convexHull 𝕜).toOrderHom s
Theorem: List.length_iota
File: Std/Data/List/Lemmas.lean

tactic: simp [iota_eq_reverse_range']
state_before: n : Nat
⊢ length (iota n) = n
Theorem: Equiv.cast_eq_iff_heq
File: Mathlib/Logic/Equiv/Defs.lean

tactic: subst h
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α β : Sort u_1
h : α = β
a : α
b : β
⊢ ↑(Equiv.cast h) a = b ↔ HEq a b

tactic: simp [coe_refl]
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Sort u_1
a b : α
⊢ ↑(Equiv.cast (_ : α = α)) a = b ↔ HEq a b
Theorem: CategoryTheory.MorphismProperty.RespectsIso.arrow_iso_iff
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: rw [← Arrow.inv_left_hom_right e.hom, hP.cancel_left_isIso, hP.cancel_right_isIso]
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.16029
inst✝ : Category D
P : MorphismProperty C
hP : RespectsIso P
f g : Arrow C
e : f ≅ g
⊢ P f.hom ↔ P g.hom
Theorem: Real.exp_neg_one_gt_d9
File: Mathlib/Data/Complex/ExponentialBounds.lean

tactic: rw [exp_neg, lt_inv _ (exp_pos _)]
state_before: ⊢ 0.36787944116 < exp (-1)

tactic: refine' lt_of_le_of_lt (sub_le_iff_le_add.1 (abs_sub_le_iff.1 exp_one_near_10).1) _
state_before: ⊢ exp 1 < 0.36787944116⁻¹


⊢ 0 < 0.36787944116

tactic: all_goals norm_num
state_before: ⊢ 1 / 10 ^ 10 + 2244083 / 825552 < 0.36787944116⁻¹


⊢ 0 < 0.36787944116

tactic: norm_num
state_before: ⊢ 0 < 0.36787944116
Theorem: Subsemiring.closure_addSubmonoid_closure
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: ext x
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 R
⊢ closure ↑(AddSubmonoid.closure s) = closure s

tactic: refine' ⟨fun hx => _, fun hx => closure_mono AddSubmonoid.subset_closure hx⟩
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
x : R
⊢ x ∈ closure ↑(AddSubmonoid.closure s) ↔ x ∈ closure s

tactic: rintro - ⟨H, rfl⟩
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
⊢ x ∈ closure s

tactic: rintro - ⟨J, rfl⟩
state_before: case h.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : Subsemiring R
⊢ x ∈ (fun t => ⋂ (_ : t ∈ {S | s ⊆ ↑S}), ↑t) H

tactic: refine' (AddSubmonoid.mem_closure.mp (mem_closure_iff.mp hx)) H.toAddSubmonoid fun y hy => _
state_before: case h.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : Subsemiring R
J : H ∈ {S | s ⊆ ↑S}
⊢ x ∈ (fun h => ↑H) J

tactic: refine' (Submonoid.mem_closure.mp hy) H.toSubmonoid fun z hz => _
state_before: case h.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : Subsemiring R
J : H ∈ {S | s ⊆ ↑S}
y : R
hy : y ∈ ↑(Submonoid.closure ↑(AddSubmonoid.closure s))
⊢ y ∈ ↑(toAddSubmonoid H)

tactic: exact (AddSubmonoid.mem_closure.mp hz) H.toAddSubmonoid fun w hw => J hw
state_before: case h.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : Subsemiring R
J : H ∈ {S | s ⊆ ↑S}
y : R
hy : y ∈ ↑(Submonoid.closure ↑(AddSubmonoid.closure s))
z : R
hz : z ∈ ↑(AddSubmonoid.closure s)
⊢ z ∈ ↑H.toSubmonoid
Theorem: Zsqrtd.norm_eq_one_iff
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rwa [← Int.coe_nat_inj', Int.natAbs_of_nonneg hx, ← @Int.cast_inj (ℤ√d) _ _,
  norm_eq_mul_conj, eq_comm] at h
state_before: d : ℤ
x : ℤ√d
h : Int.natAbs (norm x) = 1
hx : 0 ≤ norm x
⊢ 1 = x * star x

tactic: rwa [← Int.coe_nat_inj', Int.ofNat_natAbs_of_nonpos hx, ← @Int.cast_inj (ℤ√d) _ _,
  Int.cast_neg, norm_eq_mul_conj, neg_mul_eq_mul_neg, eq_comm] at h
state_before: d : ℤ
x : ℤ√d
h : Int.natAbs (norm x) = 1
hx : norm x ≤ 0
⊢ 1 = x * -star x

tactic: let ⟨y, hy⟩ := isUnit_iff_dvd_one.1 h
state_before: d : ℤ
x : ℤ√d
h : IsUnit x
⊢ Int.natAbs (norm x) = 1

tactic: have := congr_arg (Int.natAbs ∘ norm) hy
state_before: d : ℤ
x : ℤ√d
h : IsUnit x
y : ℤ√d
hy : 1 = x * y
⊢ Int.natAbs (norm x) = 1

tactic: rw [Function.comp_apply, Function.comp_apply, norm_mul, Int.natAbs_mul, norm_one,
  Int.natAbs_one, eq_comm, mul_eq_one] at this
state_before: d : ℤ
x : ℤ√d
h : IsUnit x
y : ℤ√d
hy : 1 = x * y
this : (Int.natAbs ∘ norm) 1 = (Int.natAbs ∘ norm) (x * y)
⊢ Int.natAbs (norm x) = 1

tactic: exact this.1
state_before: d : ℤ
x : ℤ√d
h : IsUnit x
y : ℤ√d
hy : 1 = x * y
this : Int.natAbs (norm x) = 1 ∧ Int.natAbs (norm y) = 1
⊢ Int.natAbs (norm x) = 1
Theorem: List.scanlTR_go_eq
File: Std/Data/List/Basic.lean

tactic: simp [scanlTR.go, scanl]
state_before: α✝¹ : Type u_1
α✝ : Type u_2
f : α✝¹ → α✝ → α✝¹
a : α✝¹
acc : Array α✝¹
⊢ scanlTR.go f [] a acc = acc.data ++ scanl f a []

tactic: simp [scanlTR.go, scanl, scanlTR_go_eq l]
state_before: α✝¹ : Type u_1
α✝ : Type u_2
f : α✝¹ → α✝ → α✝¹
a✝ : α✝¹
acc : Array α✝¹
a : α✝
l : List α✝
⊢ scanlTR.go f (a :: l) a✝ acc = acc.data ++ scanl f a✝ (a :: l)
Theorem: MeasureTheory.Measure.pi_ball
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [ball_pi _ hr, pi_pi]
state_before: ι : Type u_2
ι' : Type ?u.3159831
α : ι → Type u_1
inst✝³ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝² : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝¹ : ∀ (i : ι), SigmaFinite (μ i)
inst✝ : (i : ι) → MetricSpace (α i)
x : (i : ι) → α i
r : ℝ
hr : 0 < r
⊢ ↑↑(Measure.pi μ) (Metric.ball x r) = ∏ i : ι, ↑↑(μ i) (Metric.ball (x i) r)
Theorem: Polynomial.as_sum_support_C_mul_X_pow
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp only [C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ ∑ i in support p, ↑(monomial i) (coeff p i) = ∑ i in support p, ↑C (coeff p i) * X ^ i
Theorem: InnerProductGeometry.cos_angle_mul_norm_mul_norm
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [cos_angle, div_mul_cancel_of_imp]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ cos (angle x y) * (‖x‖ * ‖y‖) = inner x y

tactic: simp (config := { contextual := true }) [or_imp]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ ‖x‖ * ‖y‖ = 0 → inner x y = 0
Theorem: Fin.heq_fun_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: subst h
state_before: n m : ℕ
α : Sort u_1
k l : ℕ
h : k = l
f : Fin k → α
g : Fin l → α
⊢ HEq f g ↔ ∀ (i : Fin k), f i = g { val := ↑i, isLt := (_ : ↑i < l) }

tactic: simp [Function.funext_iff]
state_before: n m : ℕ
α : Sort u_1
k : ℕ
f g : Fin k → α
⊢ HEq f g ↔ ∀ (i : Fin k), f i = g { val := ↑i, isLt := (_ : ↑i < k) }
Theorem: Ordnode.eraseMin.valid
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [h.2.eq_node']
state_before: α : Type u_1
inst✝ : Preorder α
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
h : Valid (node size✝ l x r)
⊢ Valid (eraseMin (node size✝ l x r))

tactic: exact h.eraseMin_aux.1.valid
state_before: α : Type u_1
inst✝ : Preorder α
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
h : Valid (node size✝ l x r)
⊢ Valid (eraseMin (node' l x r))
Theorem: zsmul_eq_mul'
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [zsmul_eq_mul, (n.cast_commute a).eq]
state_before: α : Type ?u.278192
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Ring R
a : R
n : ℤ
⊢ n • a = a * ↑n
Theorem: Polynomial.ofFinsupp_erase
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q : R[X]
p : AddMonoidAlgebra R ℕ
n : ℕ
⊢ { toFinsupp := Finsupp.erase n p } = erase n { toFinsupp := p }

tactic: simp only [erase_def]
state_before: case mk
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
support✝ : Finset ℕ
toFun✝ : ℕ → R
mem_support_toFun✝ : ∀ (a : ℕ), a ∈ support✝ ↔ toFun✝ a ≠ 0
⊢ { toFinsupp := Finsupp.erase n { support := support✝, toFun := toFun✝, mem_support_toFun := mem_support_toFun✝ } } =
    erase n { toFinsupp := { support := support✝, toFun := toFun✝, mem_support_toFun := mem_support_toFun✝ } }
Theorem: RatFunc.lift_on_condition_of_lift_on'_condition
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [h, mul_comm q']
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
f : K[X] → K[X] → P
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
p q p' q' : K[X]
hq : q ≠ 0
hq' : q' ≠ 0
h : q' * p = q * p'
⊢ f (q' * p) (q' * q) = f (q * p') (q * q')
Theorem: Zspan.fract_fract
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: classical simp only [repr_fract_apply, Int.fract_fract]
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
x✝ : ι
⊢ ↑(↑b.repr (fract b (fract b m))) x✝ = ↑(↑b.repr (fract b m)) x✝

tactic: simp only [repr_fract_apply, Int.fract_fract]
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
x✝ : ι
⊢ ↑(↑b.repr (fract b (fract b m))) x✝ = ↑(↑b.repr (fract b m)) x✝
Theorem: norm_pow_le_mul_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: induction' n with n ih
state_before: 𝓕 : Type ?u.748962
𝕜 : Type ?u.748965
α : Type ?u.748968
ι : Type ?u.748971
κ : Type ?u.748974
E : Type u_1
F : Type ?u.748980
G : Type ?u.748983
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
a : E
⊢ ‖a ^ n‖ ≤ ↑n * ‖a‖

tactic: simpa only [pow_succ', Nat.cast_succ, add_mul, one_mul] using norm_mul_le_of_le ih le_rfl
state_before: case succ
𝓕 : Type ?u.748962
𝕜 : Type ?u.748965
α : Type ?u.748968
ι : Type ?u.748971
κ : Type ?u.748974
E : Type u_1
F : Type ?u.748980
G : Type ?u.748983
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
n : ℕ
ih : ‖a ^ n‖ ≤ ↑n * ‖a‖
⊢ ‖a ^ Nat.succ n‖ ≤ ↑(Nat.succ n) * ‖a‖

tactic: simp
state_before: case zero
𝓕 : Type ?u.748962
𝕜 : Type ?u.748965
α : Type ?u.748968
ι : Type ?u.748971
κ : Type ?u.748974
E : Type u_1
F : Type ?u.748980
G : Type ?u.748983
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ ‖a ^ Nat.zero‖ ≤ ↑Nat.zero * ‖a‖
Theorem: CircleDeg1Lift.translationNumber_eq_of_tendsto₀'
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: exact_mod_cast h
state_before: f g : CircleDeg1Lift
τ' : ℝ
h : Tendsto (fun n => (↑f^[n + 1]) 0 / (↑n + 1)) atTop (𝓝 τ')
⊢ Tendsto (fun n => (↑f^[n + 1]) 0 / ↑(n + 1)) atTop (𝓝 τ')
Theorem: SimpleGraph.Iso.symm_apply_reachable
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← Iso.reachable_iff, RelIso.apply_symm_apply]
state_before: V : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V
G'✝ : SimpleGraph V'
G'' : SimpleGraph V''
G : SimpleGraph V
G' : SimpleGraph V'
φ : G ≃g G'
u : V
v : V'
⊢ Reachable G (↑(symm φ) v) u ↔ Reachable G' v (↑φ u)
Theorem: ENNReal.toReal_mul_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [toReal_mul, top_toReal, mul_zero]
state_before: α : Type ?u.827200
β : Type ?u.827203
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ENNReal.toReal (a * ⊤) = 0
Theorem: Mathlib.Meta.NormNum.isNat_eq_false
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : AddMonoidWithOne α
inst✝ : CharZero α
n✝¹ n✝ : ℕ
h : Nat.beq n✝¹ n✝ = false
⊢ ¬↑n✝¹ = ↑n✝

tactic: exact Nat.ne_of_beq_eq_false h
state_before: α : Type u_1
inst✝¹ : AddMonoidWithOne α
inst✝ : CharZero α
n✝¹ n✝ : ℕ
h : Nat.beq n✝¹ n✝ = false
⊢ ¬n✝¹ = n✝
Theorem: IsLocallyConstant.apply_eq_of_isPreconnected
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: let U := f ⁻¹' {f y}
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
⊢ f x = f y

tactic: suffices : x ∉ Uᶜ
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
⊢ f x = f y

tactic: exact Classical.not_not.1 this
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
this : ¬x ∈ Uᶜ
⊢ f x = f y

case this
X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
⊢ ¬x ∈ Uᶜ

tactic: intro hxV
state_before: case this
X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
⊢ ¬x ∈ Uᶜ

tactic: specialize hs U (Uᶜ) (hf {f y}) (hf ({f y}ᶜ)) _ ⟨y, ⟨hy, rfl⟩⟩ ⟨x, ⟨hx, hxV⟩⟩
state_before: case this
X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
hxV : x ∈ Uᶜ
⊢ False

tactic: simp only [union_compl_self, subset_univ]
state_before: case this
X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
hs : IsPreconnected s
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
hxV : x ∈ Uᶜ
⊢ s ⊆ U ∪ Uᶜ

tactic: simp only [inter_empty, Set.not_nonempty_empty, inter_compl_self] at hs
state_before: case this
X : Type u_1
Y : Type u_2
Z : Type ?u.4691
α : Type ?u.4694
inst✝ : TopologicalSpace X
f : X → Y
hf : IsLocallyConstant f
s : Set X
x y : X
hx : x ∈ s
hy : y ∈ s
U : Set X := f ⁻¹' {f y}
hxV : x ∈ Uᶜ
hs : Set.Nonempty (s ∩ (U ∩ Uᶜ))
⊢ False
Theorem: Polynomial.eval_smul'
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

tactic: rw [← smul_eval_smul, smul_inv_smul]
state_before: M : Type ?u.43976
inst✝⁶ : Monoid M
R : Type ?u.43982
inst✝⁵ : Semiring R
inst✝⁴ : MulSemiringAction M R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : MulSemiringAction M S
G : Type u_1
inst✝¹ : Group G
inst✝ : MulSemiringAction G S
g : G
f : S[X]
x : S
⊢ eval (g • x) f = g • eval x (g⁻¹ • f)
Theorem: SimpleGraph.Subgraph.finset_card_neighborSet_eq_degree
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: rw [degree, Set.toFinset_card]
state_before: ι : Sort ?u.200590
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : V
inst✝ : Fintype ↑(neighborSet G' v)
⊢ Finset.card (Set.toFinset (neighborSet G' v)) = degree G' v
Theorem: Set.smul_set_neg
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← image_smul, ← image_neg, image_image, smul_neg]
state_before: F : Type ?u.203055
α : Type u_2
β : Type u_1
γ : Type ?u.203064
inst✝² : Monoid α
inst✝¹ : AddGroup β
inst✝ : DistribMulAction α β
a : α
s : Set α
t : Set β
⊢ a • -t = -(a • t)
Theorem: MeasureTheory.Measure.haar.is_left_invariant_haarContent
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simpa only [ENNReal.coe_eq_coe, ← NNReal.coe_eq, haarContent_apply] using
  is_left_invariant_chaar g K
state_before: G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
K₀ : PositiveCompacts G
g : G
K : Compacts G
⊢ (fun s => ↑(Content.toFun (haarContent K₀) s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) =
    (fun s => ↑(Content.toFun (haarContent K₀) s)) K
Theorem: symmDiff_bot
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff, sdiff_bot, bot_sdiff, sup_bot_eq]
state_before: ι : Type ?u.18260
α : Type u_1
β : Type ?u.18266
π : ι → Type ?u.18271
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ ⊥ = a
Theorem: LinearMap.range_le_ker_iff
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [← hy, ← comp_apply, h, zero_apply]
state_before: R : Type u_1
R₁ : Type ?u.1259709
R₂ : Type u_2
R₃ : Type u_5
R₄ : Type ?u.1259718
S : Type ?u.1259721
K : Type ?u.1259724
K₂ : Type ?u.1259727
M : Type u_3
M' : Type ?u.1259733
M₁ : Type ?u.1259736
M₂ : Type u_4
M₃ : Type u_6
M₄ : Type ?u.1259745
N : Type ?u.1259748
N₂ : Type ?u.1259751
ι : Type ?u.1259754
V : Type ?u.1259757
V₂ : Type ?u.1259760
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type ?u.1260170
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
h : comp g f = 0
x : M₂
hx : x ∈ range f
y : M
hy : ↑f y = x
⊢ ↑g x = 0
Theorem: YoungDiagram.transpose_le_iff
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: convert YoungDiagram.le_of_transpose_le h
state_before: μ ν : YoungDiagram
h : transpose μ ≤ transpose ν
⊢ μ ≤ ν

tactic: simp
state_before: case h.e'_4
μ ν : YoungDiagram
h : transpose μ ≤ transpose ν
⊢ ν = transpose (transpose ν)

tactic: rw [←transpose_transpose μ] at h
state_before: μ ν : YoungDiagram
h : μ ≤ ν
⊢ transpose μ ≤ transpose ν

tactic: exact YoungDiagram.le_of_transpose_le h
state_before: μ ν : YoungDiagram
h : transpose (transpose μ) ≤ ν
⊢ transpose μ ≤ transpose ν
Theorem: Dfinsupp.mapRange_def
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
inst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
⊢ mapRange f hf g = mk (support g) fun i => f (↑i) (↑g ↑i)

tactic: by_cases h : g i ≠ 0 <;> simp at h <;> simp [h, hf]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
inst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
i : ι
⊢ ↑(mapRange f hf g) i = ↑(mk (support g) fun i => f (↑i) (↑g ↑i)) i
Theorem: WittVector.bind₁_zero_wittPolynomial
File: Mathlib/RingTheory/WittVector/IsPoly.lean

tactic: rw [← aeval_eq_bind₁, aeval_zero, constantCoeff_wittPolynomial, RingHom.map_zero]
state_before: p : ℕ
R S : Type u
σ : Type ?u.653400
idx : Type ?u.653403
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Fact (Nat.Prime p)
n : ℕ
⊢ ↑(bind₁ 0) (wittPolynomial p R n) = 0
Theorem: norm_algebraMap
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [Algebra.algebraMap_eq_smul_one]
state_before: α : Type ?u.431038
β : Type ?u.431041
γ : Type ?u.431044
ι : Type ?u.431047
𝕜 : Type u_2
𝕜' : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedRing 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
x : 𝕜
⊢ ‖↑(algebraMap 𝕜 𝕜') x‖ = ‖x‖ * ‖1‖

tactic: exact norm_smul _ _
state_before: α : Type ?u.431038
β : Type ?u.431041
γ : Type ?u.431044
ι : Type ?u.431047
𝕜 : Type u_2
𝕜' : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedRing 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
x : 𝕜
⊢ ‖x • 1‖ = ‖x‖ * ‖1‖
Theorem: Subgroup.leftTransversals.diff_mul_diff
File: Mathlib/GroupTheory/Transfer.lean

tactic: simp_rw [Subtype.ext_iff, coe_mul, coe_mk, mul_assoc, mul_inv_cancel_left]
state_before: G : Type u_2
inst✝² : Group G
H : Subgroup G
A : Type u_1
inst✝¹ : CommGroup A
ϕ : { x // x ∈ H } →* A
R S T : ↑(leftTransversals ↑H)
inst✝ : FiniteIndex H
q : G ⧸ H
x✝ : q ∈ univ
⊢ {
        val :=
          (↑(↑(MemLeftTransversals.toEquiv (_ : ↑R ∈ leftTransversals ↑H)) q))⁻¹ *
            ↑(↑(MemLeftTransversals.toEquiv (_ : ↑S ∈ leftTransversals ↑H)) q),
        property :=
          (_ :
            (↑(↑(MemLeftTransversals.toEquiv (_ : ↑R ∈ leftTransversals ↑H)) q))⁻¹ *
                ↑(↑(MemLeftTransversals.toEquiv (_ : ↑S ∈ leftTransversals ↑H)) q) ∈
              H) } *
      {
        val :=
          (↑(↑(MemLeftTransversals.toEquiv (_ : ↑S ∈ leftTransversals ↑H)) q))⁻¹ *
            ↑(↑(MemLeftTransversals.toEquiv (_ : ↑T ∈ leftTransversals ↑H)) q),
        property :=
          (_ :
            (↑(↑(MemLeftTransversals.toEquiv (_ : ↑S ∈ leftTransversals ↑H)) q))⁻¹ *
                ↑(↑(MemLeftTransversals.toEquiv (_ : ↑T ∈ leftTransversals ↑H)) q) ∈
              H) } =
    {
      val :=
        (↑(↑(MemLeftTransversals.toEquiv (_ : ↑R ∈ leftTransversals ↑H)) q))⁻¹ *
          ↑(↑(MemLeftTransversals.toEquiv (_ : ↑T ∈ leftTransversals ↑H)) q),
      property :=
        (_ :
          (↑(↑(MemLeftTransversals.toEquiv (_ : ↑R ∈ leftTransversals ↑H)) q))⁻¹ *
              ↑(↑(MemLeftTransversals.toEquiv (_ : ↑T ∈ leftTransversals ↑H)) q) ∈
            H) }
Theorem: Num.add_ofNat'
File: Mathlib/Data/Num/Lemmas.lean

tactic: have : ∀ {n}, ofNat' n.succ = ofNat' n + 1 := ofNat'_succ
state_before: α : Type ?u.188122
m n : ℕ
⊢ ofNat' (m + n) = ofNat' m + ofNat' n

tactic: induction n <;> simp [Nat.add_zero, this, add_zero, Nat.add_succ, add_one, add_succ, *]
state_before: α : Type ?u.188122
m n : ℕ
this : ∀ {n : ℕ}, ofNat' (Nat.succ n) = ofNat' n + 1
⊢ ofNat' (m + n) = ofNat' m + ofNat' n