tasksource/leandojo huggingface dataset:
Theorem: Finset.sum_smul_const_vsub_eq_sub_weightedVSubOfPoint
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [sum_smul_vsub_eq_weightedVSubOfPoint_sub, weightedVSubOfPoint_apply_const]
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.106184
s₂ : Finset ι₂
w : ι → k
p₂ : ι → P
p₁ b : P
⊢ ∑ i in s, w i • (p₁ -ᵥ p₂ i) = (∑ i in s, w i) • (p₁ -ᵥ b) - ↑(weightedVSubOfPoint s p₂ b) w
Theorem: Ordinal.nadd_nat
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: induction' n with n hn
state_before: a b c : Ordinal
n : ℕ
⊢ a ♯ ↑n = a + ↑n

tactic: simp
state_before: case zero
a b c : Ordinal
⊢ a ♯ ↑Nat.zero = a + ↑Nat.zero

tactic: rw [Nat.cast_succ, add_one_eq_succ, nadd_succ, add_succ, hn]
state_before: case succ
a b c : Ordinal
n : ℕ
hn : a ♯ ↑n = a + ↑n
⊢ a ♯ ↑(Nat.succ n) = a + ↑(Nat.succ n)
Theorem: mem_closure_iff_nhds_basis
File: Mathlib/Topology/Basic.lean

tactic: simp only [Set.Nonempty, mem_inter_iff, exists_prop, and_comm]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t✝ : Set α
p✝ p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
p : ι → Prop
s : ι → Set α
h : HasBasis (𝓝 a) p s
t : Set α
⊢ (∀ (i : ι), p i → Set.Nonempty (s i ∩ t)) ↔ ∀ (i : ι), p i → ∃ y, y ∈ t ∧ y ∈ s i
Theorem: Nat.le_max_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.max_def]
state_before: a b : Nat
⊢ a ≤ max a b

tactic: split <;> simp [*]
state_before: a b : Nat
⊢ a ≤ if a ≤ b then b else a
Theorem: mem_closure_ne_iff_frequently_within
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp [mem_closure_iff_frequently, frequently_nhdsWithin_iff]
state_before: α : Type u_1
β : Type ?u.1018
γ : Type ?u.1021
δ : Type ?u.1024
inst✝ : TopologicalSpace α
z : α
s : Set α
⊢ z ∈ closure (s \ {z}) ↔ ∃ᶠ (x : α) in 𝓝[{z}ᶜ] z, x ∈ s
Theorem: DirectSum.lie_of_of_eq
File: Mathlib/Algebra/Lie/DirectSum.lean

tactic: have : of L j y = of L i (hij.recOn y) := Eq.rec (Eq.refl _) hij
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : j = i
x : L i
y : L j
⊢ ⁅↑(of L i) x, ↑(of L j) y⁆ = ↑(of L i) ⁅x, Eq.recOn hij y⁆

tactic: rw [this, ← lieAlgebraOf_apply R ι L i ⁅x, hij.recOn y⁆, LieHom.map_lie, lieAlgebraOf_apply,
  lieAlgebraOf_apply]
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : j = i
x : L i
y : L j
this : ↑(of L j) y = ↑(of L i) (Eq.recOn hij y)
⊢ ⁅↑(of L i) x, ↑(of L j) y⁆ = ↑(of L i) ⁅x, Eq.recOn hij y⁆
Theorem: IsLocalMinOn.hasFDerivWithinAt_nonneg
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simpa using h.neg.hasFDerivWithinAt_nonpos hf.neg hy
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMinOn f s a
hf : HasFDerivWithinAt f f' s a
y : E
hy : y ∈ posTangentConeAt s a
⊢ 0 ≤ ↑f' y
Theorem: Filter.tendsto_lift
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [Filter.lift, tendsto_iInf]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.12537
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
m : γ → β
l : Filter γ
⊢ Tendsto m l (Filter.lift f g) ↔ ∀ (s : Set α), s ∈ f → Tendsto m l (g s)
Theorem: Polynomial.ofFinsupp_single
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp [monomial]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
⊢ { toFinsupp := Finsupp.single n r } = ↑(monomial n) r
Theorem: HasDerivAt.clog_real
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

tactic: simpa only [div_eq_inv_mul] using
  (hasStrictFDerivAt_log_real h₂).hasFDerivAt.comp_hasDerivAt x h₁
state_before: α : Type ?u.37754
inst✝² : TopologicalSpace α
E : Type ?u.37760
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → ℂ
x : ℝ
f' : ℂ
h₁ : HasDerivAt f f' x
h₂ : 0 < (f x).re ∨ (f x).im ≠ 0
⊢ HasDerivAt (fun t => log (f t)) (f' / f x) x
Theorem: Nat.beq_eq_true_eq
File: src/lean/Init/Data/Nat/Basic.lean

tactic: subst h
state_before: a b : Nat
h : a = b
⊢ (a == b) = true

tactic: apply LawfulBEq.rfl
state_before: a : Nat
⊢ (a == a) = true
Theorem: Nat.lt_two_pow
File: Mathlib/Data/Nat/Pow.lean

tactic: decide
state_before: n : ℕ
⊢ 1 < 2
Theorem: isClosed_setOf_lipschitzOnWith
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [LipschitzOnWith, setOf_forall]
state_before: α✝ : Type ?u.431840
β✝ : Type ?u.431843
γ : Type ?u.431846
inst✝² : PseudoEMetricSpace α✝
α : Type u_1
β : Type u_2
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s : Set α
⊢ IsClosed {f | LipschitzOnWith K f s}

tactic: refine' isClosed_biInter fun x _ => isClosed_biInter fun y _ => isClosed_le _ _
state_before: α✝ : Type ?u.431840
β✝ : Type ?u.431843
γ : Type ?u.431846
inst✝² : PseudoEMetricSpace α✝
α : Type u_1
β : Type u_2
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s : Set α
⊢ IsClosed (⋂ (i : α) (_ : i ∈ s) (i_1 : α) (_ : i_1 ∈ s), {x | edist (x i) (x i_1) ≤ ↑K * edist i i_1})

tactic: exacts [.edist (continuous_apply x) (continuous_apply y), continuous_const]
state_before: case refine'_1
α✝ : Type ?u.431840
β✝ : Type ?u.431843
γ : Type ?u.431846
inst✝² : PseudoEMetricSpace α✝
α : Type u_1
β : Type u_2
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s : Set α
x : α
x✝¹ : x ∈ s
y : α
x✝ : y ∈ s
⊢ Continuous fun x_1 => edist (x_1 x) (x_1 y)

case refine'_2
α✝ : Type ?u.431840
β✝ : Type ?u.431843
γ : Type ?u.431846
inst✝² : PseudoEMetricSpace α✝
α : Type u_1
β : Type u_2
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s : Set α
x : α
x✝¹ : x ∈ s
y : α
x✝ : y ∈ s
⊢ Continuous fun x_1 => ↑K * edist x y
Theorem: List.ofFn_eq_pmap
File: Mathlib/Data/List/FinRange.lean

tactic: (rw [pmap_eq_map_attach];
  exact ext_get (by simp) fun i hi1 hi2 => by
      simp [get_ofFn f ⟨i, hi1⟩])
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ ofFn f = pmap (fun i hi => f { val := i, isLt := hi }) (range n) (_ : ∀ (x : ℕ), x ∈ range n → x < n)

tactic: rw [pmap_eq_map_attach]
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ ofFn f = pmap (fun i hi => f { val := i, isLt := hi }) (range n) (_ : ∀ (x : ℕ), x ∈ range n → x < n)

tactic: exact ext_get (by simp) fun i hi1 hi2 => by
    simp [get_ofFn f ⟨i, hi1⟩]
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ ofFn f = map (fun x => f { val := ↑x, isLt := (_ : ↑x < n) }) (attach (range n))

tactic: simp
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ length (ofFn f) = length (map (fun x => f { val := ↑x, isLt := (_ : ↑x < n) }) (attach (range n)))

tactic: simp [get_ofFn f ⟨i, hi1⟩]
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
i : ℕ
hi1 : i < length (ofFn f)
hi2 : i < length (map (fun x => f { val := ↑x, isLt := (_ : ↑x < n) }) (attach (range n)))
⊢ get (ofFn f) { val := i, isLt := hi1 } =
    get (map (fun x => f { val := ↑x, isLt := (_ : ↑x < n) }) (attach (range n))) { val := i, isLt := hi2 }
Theorem: binary_relation_sSup_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [sSup_apply]
state_before: α✝ : Type ?u.201468
β✝ : Type ?u.201471
β₂ : Type ?u.201474
γ : Type ?u.201477
ι : Sort ?u.201480
ι' : Sort ?u.201483
κ : ι → Sort ?u.201488
κ' : ι' → Sort ?u.201493
α : Type u_1
β : Type u_2
s : Set (α → β → Prop)
a : α
b : β
⊢ sSup s a b ↔ ∃ r, r ∈ s ∧ r a b

tactic: simp [← eq_iff_iff]
state_before: α✝ : Type ?u.201468
β✝ : Type ?u.201471
β₂ : Type ?u.201474
γ : Type ?u.201477
ι : Sort ?u.201480
ι' : Sort ?u.201483
κ : ι → Sort ?u.201488
κ' : ι' → Sort ?u.201493
α : Type u_1
β : Type u_2
s : Set (α → β → Prop)
a : α
b : β
⊢ iSup (fun f => ↑f a) b ↔ ∃ r, r ∈ s ∧ r a b
Theorem: Sym.mem_fill_iff
File: Mathlib/Data/Sym/Basic.lean

tactic: rw [fill, mem_cast, mem_append_iff, or_comm, mem_replicate]
state_before: α : Type u_1
β : Type ?u.50039
n n' m : ℕ
s✝ : Sym α n
a✝ b✝ a b : α
i : Fin (n + 1)
s : Sym α (n - ↑i)
⊢ a ∈ fill b i s ↔ ↑i ≠ 0 ∧ a = b ∨ a ∈ s
Theorem: IsClosedMap.of_nonempty
File: Mathlib/Topology/Maps.lean

tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.225202
δ : Type ?u.225205
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
h : ∀ (s : Set α), IsClosed s → Set.Nonempty s → IsClosed (f '' s)
⊢ IsClosedMap f

tactic: cases' eq_empty_or_nonempty s with h2s h2s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.225202
δ : Type ?u.225205
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
h : ∀ (s : Set α), IsClosed s → Set.Nonempty s → IsClosed (f '' s)
s : Set α
hs : IsClosed s
⊢ IsClosed (f '' s)

tactic: simp_rw [h2s, image_empty, isClosed_empty]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.225202
δ : Type ?u.225205
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
h : ∀ (s : Set α), IsClosed s → Set.Nonempty s → IsClosed (f '' s)
s : Set α
hs : IsClosed s
h2s : s = ∅
⊢ IsClosed (f '' s)

tactic: exact h s hs h2s
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.225202
δ : Type ?u.225205
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
h : ∀ (s : Set α), IsClosed s → Set.Nonempty s → IsClosed (f '' s)
s : Set α
hs : IsClosed s
h2s : Set.Nonempty s
⊢ IsClosed (f '' s)
Theorem: CategoryTheory.NonPreadditiveAbelian.lift_sub_lift
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: simp only [sub_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift a b - prod.lift c d = prod.lift (a - c) (b - d)

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b) (prod.lift c d) ≫ σ = prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ)

tactic: rw [Category.assoc, σ_comp, prod.lift_map_assoc, prod.lift_fst, prod.lift_fst, prod.lift_fst]
state_before: case h₁
C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ (prod.lift (prod.lift a b) (prod.lift c d) ≫ σ) ≫ prod.fst =
    prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ) ≫ prod.fst

tactic: rw [Category.assoc, σ_comp, prod.lift_map_assoc, prod.lift_snd, prod.lift_snd, prod.lift_snd]
state_before: case h₂
C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ (prod.lift (prod.lift a b) (prod.lift c d) ≫ σ) ≫ prod.snd =
    prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ) ≫ prod.snd
Theorem: Ideal.span_singleton_pow
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: induction' n with n ih
state_before: R : Type u
ι : Type ?u.225378
inst✝ : CommSemiring R
I J K L : Ideal R
s : R
n : ℕ
⊢ span {s} ^ n = span {s ^ n}

tactic: simp only [pow_succ, ih, span_singleton_mul_span_singleton]
state_before: case succ
R : Type u
ι : Type ?u.225378
inst✝ : CommSemiring R
I J K L : Ideal R
s : R
n : ℕ
ih : span {s} ^ n = span {s ^ n}
⊢ span {s} ^ Nat.succ n = span {s ^ Nat.succ n}

tactic: simp [Set.singleton_one]
state_before: case zero
R : Type u
ι : Type ?u.225378
inst✝ : CommSemiring R
I J K L : Ideal R
s : R
⊢ span {s} ^ Nat.zero = span {s ^ Nat.zero}
Theorem: Metric.ediam_cthickening_le
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: refine' diam_le fun x hx y hy => ENNReal.le_of_forall_pos_le_add fun δ hδ _ => _
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s t : Set α
x : α
ε : ℝ≥0
⊢ EMetric.diam (cthickening (↑ε) s) ≤ EMetric.diam s + 2 * ↑ε

tactic: rw [mem_cthickening_iff, ENNReal.ofReal_coe_nnreal] at hx hy
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x : α
hx : x ∈ cthickening (↑ε) s
y : α
hy : y ∈ cthickening (↑ε) s
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
⊢ edist x y ≤ EMetric.diam s + 2 * ↑ε + ↑δ

tactic: have hε : (ε : ℝ≥0∞) < ε + δ := ENNReal.coe_lt_coe.2 (lt_add_of_pos_right _ hδ)
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x : α
hx : infEdist x s ≤ ↑ε
y : α
hy : infEdist y s ≤ ↑ε
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
⊢ edist x y ≤ EMetric.diam s + 2 * ↑ε + ↑δ

tactic: replace hx := hx.trans_lt hε
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x : α
hx : infEdist x s ≤ ↑ε
y : α
hy : infEdist y s ≤ ↑ε
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
hε : ↑ε < ↑ε + ↑δ
⊢ edist x y ≤ EMetric.diam s + 2 * ↑ε + ↑δ

tactic: obtain ⟨x', hx', hxx'⟩ := infEdist_lt_iff.mp hx
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x y : α
hy : infEdist y s ≤ ↑ε
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
hε : ↑ε < ↑ε + ↑δ
hx : infEdist x s < ↑ε + ↑δ
⊢ edist x y ≤ EMetric.diam s + 2 * ↑ε + ↑δ

tactic: calc
  edist x y ≤ edist x x' + edist y x' := edist_triangle_right _ _ _
  _ ≤ ε + δ + (infEdist y s + EMetric.diam s) :=
    add_le_add hxx'.le (edist_le_infEdist_add_ediam hx')
  _ ≤ ε + δ + (ε + EMetric.diam s) := add_le_add_left (add_le_add_right hy _) _
  _ = _ := by rw [two_mul]; ac_rfl
state_before: case intro.intro
ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x y : α
hy : infEdist y s ≤ ↑ε
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
hε : ↑ε < ↑ε + ↑δ
hx : infEdist x s < ↑ε + ↑δ
x' : α
hx' : x' ∈ s
hxx' : edist x x' < ↑ε + ↑δ
⊢ edist x y ≤ EMetric.diam s + 2 * ↑ε + ↑δ

tactic: rw [two_mul]
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x y : α
hy : infEdist y s ≤ ↑ε
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
hε : ↑ε < ↑ε + ↑δ
hx : infEdist x s < ↑ε + ↑δ
x' : α
hx' : x' ∈ s
hxx' : edist x x' < ↑ε + ↑δ
⊢ ↑ε + ↑δ + (↑ε + EMetric.diam s) = EMetric.diam s + 2 * ↑ε + ↑δ

tactic: ac_rfl
state_before: ι : Sort ?u.116888
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝¹ : α
ε : ℝ≥0
x y : α
hy : infEdist y s ≤ ↑ε
δ : ℝ≥0
hδ : 0 < δ
x✝ : EMetric.diam s + 2 * ↑ε < ⊤
hε : ↑ε < ↑ε + ↑δ
hx : infEdist x s < ↑ε + ↑δ
x' : α
hx' : x' ∈ s
hxx' : edist x x' < ↑ε + ↑δ
⊢ ↑ε + ↑δ + (↑ε + EMetric.diam s) = EMetric.diam s + (↑ε + ↑ε) + ↑δ
Theorem: ContinuousMap.liftCover_restrict
File: Mathlib/Topology/ContinuousFunction/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58521
δ : Type ?u.58524
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : C(α, β)
ι : Type u_3
S : ι → Set α
φ : (i : ι) → C(↑(S i), β)
hφ :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    ↑(φ i) { val := x, property := hxi } = ↑(φ j) { val := x, property := hxj }
hS : ∀ (x : α), ∃ i, S i ∈ nhds x
i : ι
⊢ restrict (S i) (liftCover S φ hφ hS) = φ i

tactic: simp only [coe_restrict, Function.comp_apply, liftCover_coe]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.58521
δ : Type ?u.58524
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : C(α, β)
ι : Type u_3
S : ι → Set α
φ : (i : ι) → C(↑(S i), β)
hφ :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    ↑(φ i) { val := x, property := hxi } = ↑(φ j) { val := x, property := hxj }
hS : ∀ (x : α), ∃ i, S i ∈ nhds x
i : ι
a✝ : ↑(S i)
⊢ ↑(restrict (S i) (liftCover S φ hφ hS)) a✝ = ↑(φ i) a✝
Theorem: Linarith.lt_of_lt_of_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

tactic: simp [*]
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a < 0
hb : b = 0
⊢ a + b < 0
Theorem: Int.floor_nat_add
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← Int.cast_ofNat, floor_int_add]
state_before: F : Type ?u.135056
α : Type u_1
β : Type ?u.135062
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ : α
n : ℕ
a : α
⊢ ⌊↑n + a⌋ = ↑n + ⌊a⌋
Theorem: pow_mul
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: induction' n with n ih
state_before: α : Type ?u.15094
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✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
⊢ a ^ (m * n) = (a ^ m) ^ n

tactic: rw [Nat.mul_zero, pow_zero, pow_zero]
state_before: case zero
α : Type ?u.15094
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✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m : ℕ
⊢ a ^ (m * Nat.zero) = (a ^ m) ^ Nat.zero

tactic: rw [Nat.mul_succ, pow_add, pow_succ', ih]
state_before: case succ
α : Type ?u.15094
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✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
ih : a ^ (m * n) = (a ^ m) ^ n
⊢ a ^ (m * Nat.succ n) = (a ^ m) ^ Nat.succ n
Theorem: Ordinal.infinite_pigeonhole
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: have : ∃ a, (#β) ≤ (#f ⁻¹' {a}) := by
  by_contra' h
  apply mk_univ.not_lt
  rw [← preimage_univ, ← iUnion_of_singleton, preimage_iUnion]
  exact
    mk_iUnion_le_sum_mk.trans_lt
      ((sum_le_iSup _).trans_lt <| mul_lt_of_lt h₁ (h₂.trans_le <| cof_ord_le _) (iSup_lt h₂ h))
state_before: α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
⊢ ∃ a, (#↑(f ⁻¹' {a})) = (#β)

tactic: cases' this with x h
state_before: α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
this : ∃ a, (#β) ≤ (#↑(f ⁻¹' {a}))
⊢ ∃ a, (#↑(f ⁻¹' {a})) = (#β)

tactic: refine' ⟨x, h.antisymm' _⟩
state_before: case intro
α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
x : α
h : (#β) ≤ (#↑(f ⁻¹' {x}))
⊢ ∃ a, (#↑(f ⁻¹' {a})) = (#β)

tactic: rw [le_mk_iff_exists_set]
state_before: case intro
α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
x : α
h : (#β) ≤ (#↑(f ⁻¹' {x}))
⊢ (#↑(f ⁻¹' {x})) ≤ (#β)

tactic: exact ⟨_, rfl⟩
state_before: case intro
α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
x : α
h : (#β) ≤ (#↑(f ⁻¹' {x}))
⊢ ∃ p, (#↑p) = (#↑(f ⁻¹' {x}))

tactic: by_contra' h
state_before: α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
⊢ ∃ a, (#β) ≤ (#↑(f ⁻¹' {a}))

tactic: apply mk_univ.not_lt
state_before: α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ False

tactic: rw [← preimage_univ, ← iUnion_of_singleton, preimage_iUnion]
state_before: α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ (#↑Set.univ) < (#?m.110149)

α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ Type ?u.110148

tactic: exact
  mk_iUnion_le_sum_mk.trans_lt
    ((sum_le_iSup _).trans_lt <| mul_lt_of_lt h₁ (h₂.trans_le <| cof_ord_le _) (iSup_lt h₂ h))
state_before: α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ (#↑(⋃ (i : ?m.110216), ?m.110217 ⁻¹' {i})) < (#?m.110214)

α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ Type ?u.110212

α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ Type ?u.110211

α✝ : Type ?u.109224
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ (#β)
h₂ : (#α) < cof (ord (#β))
h : ∀ (a : α), (#↑(f ⁻¹' {a})) < (#β)
⊢ ?m.110214 → ?m.110216
Theorem: DirectedOn.insert
File: Mathlib/Order/Directed.lean

tactic: rintro x (rfl | hx) y (rfl | hy)
state_before: α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
a : α
s : Set α
hd : DirectedOn r s
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r a c ∧ r b c
⊢ DirectedOn r (Insert.insert a s)

tactic: exact ⟨y, Set.mem_insert _ _, h _, h _⟩
state_before: case inl.inl
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
y : α
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r y c ∧ r b c
⊢ ∃ z, z ∈ Insert.insert y s ∧ r y z ∧ r y z

tactic: obtain ⟨w, hws, hwr⟩ := ha y hy
state_before: case inl.inr
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
x : α
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r x c ∧ r b c
y : α
hy : y ∈ s
⊢ ∃ z, z ∈ Insert.insert x s ∧ r x z ∧ r y z

tactic: exact ⟨w, Set.mem_insert_of_mem _ hws, hwr⟩
state_before: case inl.inr.intro.intro
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
x : α
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r x c ∧ r b c
y : α
hy : y ∈ s
w : α
hws : w ∈ s
hwr : r x w ∧ r y w
⊢ ∃ z, z ∈ Insert.insert x s ∧ r x z ∧ r y z

tactic: obtain ⟨w, hws, hwr⟩ := ha x hx
state_before: case inr.inl
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
x : α
hx : x ∈ s
y : α
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r y c ∧ r b c
⊢ ∃ z, z ∈ Insert.insert y s ∧ r x z ∧ r y z

tactic: exact ⟨w, Set.mem_insert_of_mem _ hws, hwr.symm⟩
state_before: case inr.inl.intro.intro
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
x : α
hx : x ∈ s
y : α
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r y c ∧ r b c
w : α
hws : w ∈ s
hwr : r y w ∧ r x w
⊢ ∃ z, z ∈ Insert.insert y s ∧ r x z ∧ r y z

tactic: obtain ⟨w, hws, hwr⟩ := hd x hx y hy
state_before: case inr.inr
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
a : α
s : Set α
hd : DirectedOn r s
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r a c ∧ r b c
x : α
hx : x ∈ s
y : α
hy : y ∈ s
⊢ ∃ z, z ∈ Insert.insert a s ∧ r x z ∧ r y z

tactic: exact ⟨w, Set.mem_insert_of_mem _ hws, hwr⟩
state_before: case inr.inr.intro.intro
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
a : α
s : Set α
hd : DirectedOn r s
ha : ∀ (b : α), b ∈ s → ∃ c, c ∈ s ∧ r a c ∧ r b c
x : α
hx : x ∈ s
y : α
hy : y ∈ s
w : α
hws : w ∈ s
hwr : r x w ∧ r y w
⊢ ∃ z, z ∈ Insert.insert a s ∧ r x z ∧ r y z
Theorem: MeasureTheory.snorm_eq_snorm'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm, hp_ne_zero, hp_ne_top]
state_before: α : Type u_1
E : Type ?u.375839
F : Type u_2
G : Type ?u.375845
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
⊢ snorm f p μ = snorm' f (ENNReal.toReal p) μ
Theorem: FixedPoints.smul_polynomial
File: Mathlib/FieldTheory/Fixed.lean

tactic: rw [Polynomial.smul_C, smul]
state_before: M : Type u
inst✝⁴ : Monoid M
G : Type u
inst✝³ : Group G
F : Type v
inst✝² : Field F
inst✝¹ : MulSemiringAction M F
inst✝ : MulSemiringAction G F
m✝ m : M
p : Polynomial { x // x ∈ subfield M F }
x : { x // x ∈ subfield M F }
⊢ m • ↑Polynomial.C x = ↑Polynomial.C x

tactic: rw [smul_add, ihp, ihq]
state_before: M : Type u
inst✝⁴ : Monoid M
G : Type u
inst✝³ : Group G
F : Type v
inst✝² : Field F
inst✝¹ : MulSemiringAction M F
inst✝ : MulSemiringAction G F
m✝ m : M
p✝ p q : Polynomial { x // x ∈ subfield M F }
ihp : m • p = p
ihq : m • q = q
⊢ m • (p + q) = p + q

tactic: rw [smul_mul', Polynomial.smul_C, smul, smul_pow', Polynomial.smul_X]
state_before: M : Type u
inst✝⁴ : Monoid M
G : Type u
inst✝³ : Group G
F : Type v
inst✝² : Field F
inst✝¹ : MulSemiringAction M F
inst✝ : MulSemiringAction G F
m✝ m : M
p : Polynomial { x // x ∈ subfield M F }
n : ℕ
x : { x // x ∈ subfield M F }
x✝ : m • (↑Polynomial.C x * Polynomial.X ^ n) = ↑Polynomial.C x * Polynomial.X ^ n
⊢ m • (↑Polynomial.C x * Polynomial.X ^ (n + 1)) = ↑Polynomial.C x * Polynomial.X ^ (n + 1)