tasksource/leandojo huggingface dataset:
Theorem: Finset.prod_lt_prod_of_subset'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: rw [prod_insert hs]
state_before: ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
⊢ ∏ j in s, f j < ∏ j in insert i s, f j

tactic: exact lt_mul_of_one_lt_left' (∏ j in s, f j) hlt
state_before: ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
⊢ ∏ j in s, f j < f i * ∏ x in s, f x

tactic: apply prod_le_prod_of_subset_of_one_le'
state_before: ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
⊢ ∏ j in insert i s, f j ≤ ∏ j in t, f j

tactic: simp [Finset.insert_subset, h, ht]
state_before: case h
ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
⊢ insert i s ⊆ t

tactic: intro x hx h'x
state_before: case hf
ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
⊢ ∀ (i_1 : ι), i_1 ∈ t → ¬i_1 ∈ insert i s → 1 ≤ f i_1

tactic: simp only [mem_insert, not_or] at h'x
state_before: case hf
ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
x : ι
hx : x ∈ t
h'x : ¬x ∈ insert i s
⊢ 1 ≤ f x

tactic: exact hle x hx h'x.2
state_before: case hf
ι : Type u_1
α : Type ?u.129835
β : Type ?u.129838
M : Type u_2
N : Type ?u.129844
G : Type ?u.129847
k : Type ?u.129850
R : Type ?u.129853
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : s ⊆ t
i : ι
ht : i ∈ t
hs : ¬i ∈ s
hlt : 1 < f i
hle : ∀ (j : ι), j ∈ t → ¬j ∈ s → 1 ≤ f j
x : ι
hx : x ∈ t
h'x : ¬x = i ∧ ¬x ∈ s
⊢ 1 ≤ f x
Theorem: Order.PFilter.principal_le_principal_iff
File: Mathlib/Order/PFilter.lean

tactic: simp
state_before: P : Type u_1
inst✝ : Preorder P
x y : P
F s t : PFilter P
p q : P
⊢ principal q ≤ principal p ↔ p ≤ q
Theorem: Homeomorph.symm_map_nhds_eq
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [h.symm.map_nhds_eq, h.symm_apply_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68858
δ : Type ?u.68861
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
x : α
⊢ map (↑(Homeomorph.symm h)) (𝓝 (↑h x)) = 𝓝 x
Theorem: EMetric.mem_ball_comm
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: rw [mem_ball', mem_ball]
state_before: α : Type u
β : Type v
X : Type ?u.189193
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ x ∈ ball y ε ↔ y ∈ ball x ε
Theorem: Matrix.rank_submatrix
File: Mathlib/Data/Matrix/Rank.lean

tactic: simpa only [reindex_apply] using rank_reindex e₁.symm e₂.symm A
state_before: l : Type ?u.188785
m : Type u_1
n : Type u_3
o : Type ?u.188794
R : Type u_2
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : Fintype m
A : Matrix m m R
e₁ e₂ : n ≃ m
⊢ rank (submatrix A ↑e₁ ↑e₂) = rank A
Theorem: Polynomial.coe_add
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext
state_before: σ : Type ?u.4308129
R : Type u_1
inst✝ : CommSemiring R
φ ψ : R[X]
⊢ ↑(φ + ψ) = ↑φ + ↑ψ

tactic: simp
state_before: case h
σ : Type ?u.4308129
R : Type u_1
inst✝ : CommSemiring R
φ ψ : R[X]
n✝ : ℕ
⊢ ↑(PowerSeries.coeff R n✝) ↑(φ + ψ) = ↑(PowerSeries.coeff R n✝) (↑φ + ↑ψ)
Theorem: CauSeq.add_limZero
File: Mathlib/Data/Real/CauSeq.lean

tactic: let ⟨H₁, H₂⟩ := H _ ij
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abv (↑f j) < ε / 2 ∧ abv (↑g j) < ε / 2
j : ℕ
ij : j ≥ i
⊢ abv (↑(f + g) j) < ε

tactic: simpa [add_halves ε] using lt_of_le_of_lt (abv_add abv _ _) (add_lt_add H₁ H₂)
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : LimZero f
hg : LimZero g
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ (j : ℕ), j ≥ i → abv (↑f j) < ε / 2 ∧ abv (↑g j) < ε / 2
j : ℕ
ij : j ≥ i
H₁ : abv (↑f j) < ε / 2
H₂ : abv (↑g j) < ε / 2
⊢ abv (↑(f + g) j) < ε
Theorem: Filter.isUnit_iff
File: Mathlib/Order/Filter/Pointwise.lean

tactic: constructor
state_before: F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
f g : Filter α
⊢ IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a

tactic: rintro ⟨u, rfl⟩
state_before: case mp
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
f g : Filter α
⊢ IsUnit f → ∃ a, f = pure a ∧ IsUnit a

tactic: obtain ⟨a, b, ha, hb, h⟩ := Filter.mul_eq_one_iff.1 u.mul_inv
state_before: case mp.intro
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
g : Filter α
u : (Filter α)ˣ
⊢ ∃ a, ↑u = pure a ∧ IsUnit a

tactic: refine' ⟨a, ha, ⟨a, b, h, pure_injective _⟩, rfl⟩
state_before: case mp.intro.intro.intro.intro.intro
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
g : Filter α
u : (Filter α)ˣ
a b : α
ha : ↑u = pure a
hb : ↑u⁻¹ = pure b
h : a * b = 1
⊢ ∃ a, ↑u = pure a ∧ IsUnit a

tactic: rw [← pure_mul_pure, ← ha, ← hb]
state_before: case mp.intro.intro.intro.intro.intro
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
g : Filter α
u : (Filter α)ˣ
a b : α
ha : ↑u = pure a
hb : ↑u⁻¹ = pure b
h : a * b = 1
⊢ pure (b * a) = pure 1

tactic: exact u.inv_mul
state_before: case mp.intro.intro.intro.intro.intro
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
g : Filter α
u : (Filter α)ˣ
a b : α
ha : ↑u = pure a
hb : ↑u⁻¹ = pure b
h : a * b = 1
⊢ ↑u⁻¹ * ↑u = pure 1

tactic: rintro ⟨a, rfl, ha⟩
state_before: case mpr
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
f g : Filter α
⊢ (∃ a, f = pure a ∧ IsUnit a) → IsUnit f

tactic: exact ha.filter
state_before: case mpr.intro.intro
F : Type ?u.300168
α : Type u_1
β : Type ?u.300174
γ : Type ?u.300177
δ : Type ?u.300180
ε : Type ?u.300183
inst✝ : DivisionMonoid α
g : Filter α
a : α
ha : IsUnit a
⊢ IsUnit (pure a)
Theorem: IsUnit.mul_eq_mul_of_div_eq_div
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [← mul_one a, ← hb.div_self, ← mul_comm_div, h, div_mul_eq_mul_div, hd.div_mul_cancel]
state_before: F : Type ?u.64657
G : Type ?u.64660
α : Type u_1
M : Type ?u.64666
N : Type ?u.64669
inst✝ : DivisionCommMonoid α
a✝ b c✝ d : α
hb : IsUnit b
hd : IsUnit d
a c : α
h : a / b = c / d
⊢ a * d = c * b
Theorem: dvd_of_mul_left_dvd
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: simp [ceq]
state_before: α : Type u_1
inst✝ : CommSemigroup α
a b c : α
h : a * b ∣ c
d : α
ceq : c = a * b * d
⊢ b * (a * d) = c
Theorem: MeasureTheory.OuterMeasure.trim_binop
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rcases exists_measurable_superset_forall_eq_trim ![m₁, m₂, m₃] s with ⟨t, _hst, _ht, htm⟩
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), ↑m₁ s = op (↑m₂ s) (↑m₃ s)
s : Set α
⊢ ↑(trim m₁) s = op (↑(trim m₂) s) (↑(trim m₃) s)

tactic: simp only [Fin.forall_fin_succ, Matrix.cons_val_zero, Matrix.cons_val_succ] at htm
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), ↑m₁ s = op (↑m₂ s) (↑m₃ s)
s t : Set α
_hst : s ⊆ t
_ht : MeasurableSet t
htm :
  ∀ (i : Fin (Nat.succ (Nat.succ (Nat.succ 0)))),
    ↑(Matrix.vecCons m₁ ![m₂, m₃] i) t = ↑(trim (Matrix.vecCons m₁ ![m₂, m₃] i)) s
⊢ ↑(trim m₁) s = op (↑(trim m₂) s) (↑(trim m₃) s)

tactic: rw [← htm.1, ← htm.2.1, ← htm.2.2.1, h]
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), ↑m₁ s = op (↑m₂ s) (↑m₃ s)
s t : Set α
_hst : s ⊆ t
_ht : MeasurableSet t
htm : ↑m₁ t = ↑(trim m₁) s ∧ ↑m₂ t = ↑(trim m₂) s ∧ ↑m₃ t = ↑(trim m₃) s ∧ ∀ (i : Fin 0), ↑![] t = ↑(trim ![]) s
⊢ ↑(trim m₁) s = op (↑(trim m₂) s) (↑(trim m₃) s)
Theorem: Polynomial.monomial_one_right_eq_X_pow
File: Mathlib/Data/Polynomial/Basic.lean

tactic: induction' n with n ih
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ ↑(monomial n) 1 = X ^ n

tactic: simp [monomial_zero_one]
state_before: case zero
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ↑(monomial Nat.zero) 1 = X ^ Nat.zero

tactic: rw [pow_succ, ← ih, ← monomial_one_one_eq_X, monomial_mul_monomial, add_comm, one_mul]
state_before: case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
ih : ↑(monomial n) 1 = X ^ n
⊢ ↑(monomial (Nat.succ n)) 1 = X ^ Nat.succ n
Theorem: integrableOn_Ioi_rpow_of_lt
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

tactic: have hd : ∀ (x : ℝ) (_ : x ∈ Ici c), HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x := by
  intro x hx
  convert (hasDerivAt_rpow_const (p := a + 1) (Or.inl (hc.trans_le hx).ne')).div_const _ using 1
  field_simp [show a + 1 ≠ 0 from ne_of_lt (by linarith), mul_comm]
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
⊢ IntegrableOn (fun t => t ^ a) (Ioi c)

tactic: have ht : Tendsto (fun t => t ^ (a + 1) / (a + 1)) atTop (𝓝 (0 / (a + 1))) := by
  apply Tendsto.div_const
  simpa only [neg_neg] using tendsto_rpow_neg_atTop (by linarith : 0 < -(a + 1))
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
hd : ∀ (x : ℝ), x ∈ Ici c → HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x
⊢ IntegrableOn (fun t => t ^ a) (Ioi c)

tactic: exact
  integrableOn_Ioi_deriv_of_nonneg' hd (fun t ht => rpow_nonneg_of_nonneg (hc.trans ht).le a) ht
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
hd : ∀ (x : ℝ), x ∈ Ici c → HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x
ht : Tendsto (fun t => t ^ (a + 1) / (a + 1)) atTop (𝓝 (0 / (a + 1)))
⊢ IntegrableOn (fun t => t ^ a) (Ioi c)

tactic: intro x hx
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
⊢ ∀ (x : ℝ), x ∈ Ici c → HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x

tactic: convert (hasDerivAt_rpow_const (p := a + 1) (Or.inl (hc.trans_le hx).ne')).div_const _ using 1
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
x : ℝ
hx : x ∈ Ici c
⊢ HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x

tactic: field_simp [show a + 1 ≠ 0 from ne_of_lt (by linarith), mul_comm]
state_before: case h.e'_7
a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
x : ℝ
hx : x ∈ Ici c
⊢ x ^ a = (a + 1) * x ^ (a + 1 - 1) / (a + 1)

tactic: linarith
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
x : ℝ
hx : x ∈ Ici c
⊢ a + 1 < 0

tactic: apply Tendsto.div_const
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
hd : ∀ (x : ℝ), x ∈ Ici c → HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x
⊢ Tendsto (fun t => t ^ (a + 1) / (a + 1)) atTop (𝓝 (0 / (a + 1)))

tactic: simpa only [neg_neg] using tendsto_rpow_neg_atTop (by linarith : 0 < -(a + 1))
state_before: case hf
a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
hd : ∀ (x : ℝ), x ∈ Ici c → HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x
⊢ Tendsto (fun a_1 => a_1 ^ (a + 1)) atTop (𝓝 0)

tactic: linarith
state_before: a : ℝ
ha : a < -1
c : ℝ
hc : 0 < c
hd : ∀ (x : ℝ), x ∈ Ici c → HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x
⊢ 0 < -(a + 1)
Theorem: Nat.snd_mem_divisors_of_mem_antidiagonal
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [mem_divisorsAntidiagonal] at h
state_before: n : ℕ
x : ℕ × ℕ
h : x ∈ divisorsAntidiagonal n
⊢ x.snd ∈ divisors n

tactic: simp [Dvd.intro_left _ h.1, h.2]
state_before: n : ℕ
x : ℕ × ℕ
h : x.fst * x.snd = n ∧ n ≠ 0
⊢ x.snd ∈ divisors n
Theorem: AddCircle.liftIco_continuous
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: rw [liftIco_eq_lift_Icc hf]
state_before: 𝕜 : Type u_2
B : Type u_1
inst✝⁴ : LinearOrderedAddCommGroup 𝕜
inst✝³ : TopologicalSpace 𝕜
inst✝² : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝¹ : Archimedean 𝕜
inst✝ : TopologicalSpace B
f : 𝕜 → B
hf : f a = f (a + p)
hc : ContinuousOn f (Icc a (a + p))
⊢ Continuous (liftIco p a f)

tactic: refine' Continuous.comp _ (homeoIccQuot p a).continuous_toFun
state_before: 𝕜 : Type u_2
B : Type u_1
inst✝⁴ : LinearOrderedAddCommGroup 𝕜
inst✝³ : TopologicalSpace 𝕜
inst✝² : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝¹ : Archimedean 𝕜
inst✝ : TopologicalSpace B
f : 𝕜 → B
hf : f a = f (a + p)
hc : ContinuousOn f (Icc a (a + p))
⊢ Continuous
    (Quot.lift (restrict (Icc a (a + p)) f)
        (_ :
          ∀ (a_1 b : ↑(Icc a (a + p))),
            EndpointIdent p a a_1 b → restrict (Icc a (a + p)) f a_1 = restrict (Icc a (a + p)) f b) ∘
      ↑(equivIccQuot p a))

tactic: exact continuous_coinduced_dom.mpr (continuousOn_iff_continuous_restrict.mp hc)
state_before: 𝕜 : Type u_2
B : Type u_1
inst✝⁴ : LinearOrderedAddCommGroup 𝕜
inst✝³ : TopologicalSpace 𝕜
inst✝² : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝¹ : Archimedean 𝕜
inst✝ : TopologicalSpace B
f : 𝕜 → B
hf : f a = f (a + p)
hc : ContinuousOn f (Icc a (a + p))
⊢ Continuous
    (Quot.lift (restrict (Icc a (a + p)) f)
      (_ :
        ∀ (a_1 b : ↑(Icc a (a + p))),
          EndpointIdent p a a_1 b → restrict (Icc a (a + p)) f a_1 = restrict (Icc a (a + p)) f b))
Theorem: Nat.preimage_Iic
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.76506
α : Type u_1
β : Type ?u.76512
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
⊢ Nat.cast ⁻¹' Iic a = Iic ⌊a⌋₊

tactic: simp [le_floor_iff, ha]
state_before: case h
F : Type ?u.76506
α : Type u_1
β : Type ?u.76512
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Iic a ↔ x✝ ∈ Iic ⌊a⌋₊
Theorem: Set.preimage_eq
File: Mathlib/Data/Rel.lean

tactic: simp [Set.preimage, Function.graph, Rel.preimage, Rel.inv, flip, Rel.image]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.40784
f : α → β
s : Set β
⊢ f ⁻¹' s = Rel.preimage (Function.graph f) s
Theorem: Subtype.coe_image_of_subset
File: Mathlib/Data/Set/Image.lean

tactic: ext x
state_before: α : Type u_1
s t : Set α
h : t ⊆ s
⊢ val '' {x | ↑x ∈ t} = t

tactic: rw [Set.mem_image]
state_before: case h
α : Type u_1
s t : Set α
h : t ⊆ s
x : α
⊢ x ∈ val '' {x | ↑x ∈ t} ↔ x ∈ t

tactic: exact ⟨fun ⟨_, hx', hx⟩ => hx ▸ hx', fun hx => ⟨⟨x, h hx⟩, hx, rfl⟩⟩
state_before: case h
α : Type u_1
s t : Set α
h : t ⊆ s
x : α
⊢ (∃ x_1, x_1 ∈ {x | ↑x ∈ t} ∧ ↑x_1 = x) ↔ x ∈ t
Theorem: Prod.lt_iff
File: Mathlib/Order/Basic.lean

tactic: refine' ⟨fun h ↦ _, _⟩
state_before: ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x < y ↔ x.fst < y.fst ∧ x.snd ≤ y.snd ∨ x.fst ≤ y.fst ∧ x.snd < y.snd

tactic: by_cases h₁ : y.1 ≤ x.1
state_before: case refine'_1
ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x < y
⊢ x.fst < y.fst ∧ x.snd ≤ y.snd ∨ x.fst ≤ y.fst ∧ x.snd < y.snd

tactic: exact Or.inr ⟨h.1.1, LE.le.lt_of_not_le h.1.2 fun h₂ ↦ h.2 ⟨h₁, h₂⟩⟩
state_before: case pos
ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x < y
h₁ : y.fst ≤ x.fst
⊢ x.fst < y.fst ∧ x.snd ≤ y.snd ∨ x.fst ≤ y.fst ∧ x.snd < y.snd

tactic: exact Or.inl ⟨LE.le.lt_of_not_le h.1.1 h₁, h.1.2⟩
state_before: case neg
ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x < y
h₁ : ¬y.fst ≤ x.fst
⊢ x.fst < y.fst ∧ x.snd ≤ y.snd ∨ x.fst ≤ y.fst ∧ x.snd < y.snd

tactic: rintro (⟨h₁, h₂⟩ | ⟨h₁, h₂⟩)
state_before: case refine'_2
ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x.fst < y.fst ∧ x.snd ≤ y.snd ∨ x.fst ≤ y.fst ∧ x.snd < y.snd → x < y

tactic: exact ⟨⟨h₁.le, h₂⟩, fun h ↦ h₁.not_le h.1⟩
state_before: case refine'_2.inl.intro
ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h₁ : x.fst < y.fst
h₂ : x.snd ≤ y.snd
⊢ x < y

tactic: exact ⟨⟨h₁, h₂.le⟩, fun h ↦ h₂.not_le h.2⟩
state_before: case refine'_2.inr.intro
ι : Type ?u.107734
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.107745
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h₁ : x.fst ≤ y.fst
h₂ : x.snd < y.snd
⊢ x < y
Theorem: Multiset.mem_Ici
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [Ici, ← Finset.mem_def, Finset.mem_Ici]
state_before: α : Type u_1
β : Type ?u.33502
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrderTop α
a x : α
⊢ x ∈ Ici a ↔ a ≤ x
Theorem: unitInterval.qRight_one_left
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: dsimp only
state_before: θ : ↑I
⊢ 1 * (1 + ↑(1, θ).snd) ≤ 2 * ↑(1, θ).fst

tactic: rw [coe_one, one_mul, mul_one, add_comm, ← one_add_one_eq_two]
state_before: θ : ↑I
⊢ 1 * (1 + ↑θ) ≤ 2 * ↑1

tactic: simp only [add_le_add_iff_right]
state_before: θ : ↑I
⊢ ↑θ + 1 ≤ 1 + 1

tactic: exact le_one _
state_before: θ : ↑I
⊢ ↑θ ≤ 1
Theorem: Finsupp.card_support_le_one
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [card_le_one_iff_subset_singleton, support_subset_singleton]
state_before: α : Type u_1
β : Type ?u.137292
γ : Type ?u.137295
ι : Type ?u.137298
M : Type u_2
M' : Type ?u.137304
N : Type ?u.137307
P : Type ?u.137310
G : Type ?u.137313
H : Type ?u.137316
R : Type ?u.137319
S : Type ?u.137322
inst✝¹ : Zero M
a a' : α
b : M
inst✝ : Nonempty α
f : α →₀ M
⊢ card f.support ≤ 1 ↔ ∃ a, f = single a (↑f a)
Theorem: Polynomial.derivative_C
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp [derivative_apply]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝ : Semiring R
a : R
⊢ ↑derivative (↑C a) = 0
Theorem: Pretrivialization.symm_apply_mk_proj
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [← e.coe_fst ex, Prod.mk.eta, ← e.coe_coe, e.left_inv ex]
state_before: ι : Type ?u.8645
B : Type u_2
F : Type u_3
E : B → Type ?u.8656
Z : Type u_1
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ x : Z
ex : x ∈ e.source
⊢ ↑(LocalEquiv.symm e.toLocalEquiv) (proj x, (↑e x).snd) = x
Theorem: matrixEquivTensor_apply_std_basis
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: have t : ∀ p : n × n, i = p.1 ∧ j = p.2 ↔ p = (i, j) := by aesop
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : Fintype n
inst✝ : DecidableEq n
i j : n
x : A
⊢ ↑(matrixEquivTensor R A n) (stdBasisMatrix i j x) = x ⊗ₜ[R] stdBasisMatrix i j 1

tactic: simp [ite_tmul, t, stdBasisMatrix]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : Fintype n
inst✝ : DecidableEq n
i j : n
x : A
t : ∀ (p : n × n), i = p.fst ∧ j = p.snd ↔ p = (i, j)
⊢ ↑(matrixEquivTensor R A n) (stdBasisMatrix i j x) = x ⊗ₜ[R] stdBasisMatrix i j 1

tactic: aesop
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : Fintype n
inst✝ : DecidableEq n
i j : n
x : A
⊢ ∀ (p : n × n), i = p.fst ∧ j = p.snd ↔ p = (i, j)
Theorem: LipschitzWith.max_const
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [max_eq_left (zero_le Kf)] using hf.max (LipschitzWith.const a)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
Kf Kg : ℝ≥0
hf : LipschitzWith Kf f
a : ℝ
⊢ LipschitzWith Kf fun x => max (f x) a
Theorem: modulePolynomialOfEndo.isScalarTower
File: Mathlib/RingTheory/FiniteType.lean

tactic: letI := modulePolynomialOfEndo f
state_before: R : Type ?u.731560
inst✝² : CommRing R
M : Type ?u.731566
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
⊢ SMul R[X] M

tactic: infer_instance
state_before: R : Type ?u.731560
inst✝² : CommRing R
M : Type ?u.731566
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
this : Module R[X] M := modulePolynomialOfEndo f
⊢ SMul R[X] M

tactic: let _ := modulePolynomialOfEndo f
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
⊢ IsScalarTower R R[X] M

tactic: constructor
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
x✝ : Module R[X] M := modulePolynomialOfEndo f
⊢ IsScalarTower R R[X] M

tactic: intro x y z
state_before: case smul_assoc
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
x✝ : Module R[X] M := modulePolynomialOfEndo f
⊢ ∀ (x : R) (y : R[X]) (z : M), (x • y) • z = x • y • z

tactic: simp
state_before: case smul_assoc
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
x✝ : Module R[X] M := modulePolynomialOfEndo f
x : R
y : R[X]
z : M
⊢ (x • y) • z = x • y • z
Theorem: add_tsub_add_le_tsub_left
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, add_assoc]
state_before: α : Type u_1
β : Type ?u.19397
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b - (a + c) ≤ b - c

tactic: exact add_le_add_left le_add_tsub _
state_before: α : Type u_1
β : Type ?u.19397
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b ≤ a + (c + (b - c))
Theorem: Std.RBNode.Ordered.modify
File: Std/Data/RBMap/Alter.lean

tactic: rw [eq] at H
state_before: α : Type u_1
cut : α → Ordering
cmp : α → α → Ordering
f : α → α
t : RBNode α
H : OnRoot (fun x => cmpEq cmp (f x) x) (RBNode.zoom cut t Path.root).fst
h : Ordered cmp t
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : Path α
eq : RBNode.zoom cut t Path.root = (node c✝ l✝ v✝ r✝, x✝)
⊢ Path.RootOrdered cmp x✝ (f v✝) ∧ OnRoot (cmpEq cmp (f v✝)) (node c✝ l✝ v✝ r✝)

tactic: exact ⟨H.RootOrdered_congr.2 (h.zoom eq).2.2.1.1, H⟩
state_before: α : Type u_1
cut : α → Ordering
cmp : α → α → Ordering
f : α → α
t : RBNode α
h : Ordered cmp t
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : Path α
H : OnRoot (fun x => cmpEq cmp (f x) x) (node c✝ l✝ v✝ r✝, x✝).fst
eq : RBNode.zoom cut t Path.root = (node c✝ l✝ v✝ r✝, x✝)
⊢ Path.RootOrdered cmp x✝ (f v✝) ∧ OnRoot (cmpEq cmp (f v✝)) (node c✝ l✝ v✝ r✝)