tasksource/leandojo huggingface dataset:
Theorem: RegularExpression.add_rmatch_iff
File: Mathlib/Computability/RegularExpressions.lean

tactic: induction' x with _ _ ih generalizing P Q
state_before: α : Type u_1
β : Type ?u.41307
γ : Type ?u.41310
dec : DecidableEq α
a b : α
P Q : RegularExpression α
x : List α
⊢ rmatch (P + Q) x = true ↔ rmatch P x = true ∨ rmatch Q x = true

tactic: simp only [rmatch, matchEpsilon, Bool.or_coe_iff]
state_before: case nil
α : Type u_1
β : Type ?u.41307
γ : Type ?u.41310
dec : DecidableEq α
a b : α
P✝ Q✝ P Q : RegularExpression α
⊢ rmatch (P + Q) [] = true ↔ rmatch P [] = true ∨ rmatch Q [] = true

tactic: repeat' rw [rmatch]
state_before: case cons
α : Type u_1
β : Type ?u.41307
γ : Type ?u.41310
dec : DecidableEq α
a b : α
P✝ Q✝ : RegularExpression α
head✝ : α
tail✝ : List α
ih : ∀ (P Q : RegularExpression α), rmatch (P + Q) tail✝ = true ↔ rmatch P tail✝ = true ∨ rmatch Q tail✝ = true
P Q : RegularExpression α
⊢ rmatch (P + Q) (head✝ :: tail✝) = true ↔ rmatch P (head✝ :: tail✝) = true ∨ rmatch Q (head✝ :: tail✝) = true

tactic: rw [deriv_add]
state_before: case cons
α : Type u_1
β : Type ?u.41307
γ : Type ?u.41310
dec : DecidableEq α
a b : α
P✝ Q✝ : RegularExpression α
head✝ : α
tail✝ : List α
ih : ∀ (P Q : RegularExpression α), rmatch (P + Q) tail✝ = true ↔ rmatch P tail✝ = true ∨ rmatch Q tail✝ = true
P Q : RegularExpression α
⊢ rmatch (deriv (P + Q) head✝) tail✝ = true ↔ rmatch (deriv P head✝) tail✝ = true ∨ rmatch (deriv Q head✝) tail✝ = true

tactic: exact ih _ _
state_before: case cons
α : Type u_1
β : Type ?u.41307
γ : Type ?u.41310
dec : DecidableEq α
a b : α
P✝ Q✝ : RegularExpression α
head✝ : α
tail✝ : List α
ih : ∀ (P Q : RegularExpression α), rmatch (P + Q) tail✝ = true ↔ rmatch P tail✝ = true ∨ rmatch Q tail✝ = true
P Q : RegularExpression α
⊢ rmatch (deriv P head✝ + deriv Q head✝) tail✝ = true ↔
    rmatch (deriv P head✝) tail✝ = true ∨ rmatch (deriv Q head✝) tail✝ = true

tactic: rw [rmatch]
state_before: case cons
α : Type u_1
β : Type ?u.41307
γ : Type ?u.41310
dec : DecidableEq α
a b : α
P✝ Q✝ : RegularExpression α
head✝ : α
tail✝ : List α
ih : ∀ (P Q : RegularExpression α), rmatch (P + Q) tail✝ = true ↔ rmatch P tail✝ = true ∨ rmatch Q tail✝ = true
P Q : RegularExpression α
⊢ rmatch (deriv (P + Q) head✝) tail✝ = true ↔ rmatch (deriv P head✝) tail✝ = true ∨ rmatch (deriv Q head✝) tail✝ = true
Theorem: HomogeneousIdeal.toIdeal_homogeneousCore_eq_self
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: ext1
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.107238
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I : HomogeneousIdeal 𝒜
⊢ Ideal.homogeneousCore 𝒜 (toIdeal I) = I

tactic: convert Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self I.isHomogeneous
state_before: case h
ι : Type u_1
σ : Type u_2
R : Type ?u.107238
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ : Ideal A
I : HomogeneousIdeal 𝒜
⊢ toIdeal (Ideal.homogeneousCore 𝒜 (toIdeal I)) = toIdeal I
Theorem: ContractingWith.edist_efixedPoint_le'
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: convert hf.apriori_edist_iterate_efixedPoint_le' hsc hsf hxs hx 0
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
s : Set α
hsc : IsComplete s
hsf : MapsTo f s s
hf : ContractingWith K (MapsTo.restrict f s s hsf)
x : α
hxs : x ∈ s
hx : edist x (f x) ≠ ⊤
⊢ edist x (efixedPoint' f hsc hsf hf x hxs hx) ≤ edist x (f x) / (1 - ↑K)

tactic: rw [pow_zero, mul_one]
state_before: case h.e'_4.h.e'_5
α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
s : Set α
hsc : IsComplete s
hsf : MapsTo f s s
hf : ContractingWith K (MapsTo.restrict f s s hsf)
x : α
hxs : x ∈ s
hx : edist x (f x) ≠ ⊤
⊢ edist x (f x) = edist x (f x) * ↑K ^ 0
Theorem: Filter.tendsto_mul_const_atBot_iff_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [mul_comm _ r, tendsto_const_mul_atBot_iff_pos h]
state_before: ι : Type ?u.243936
ι' : Type ?u.243939
α : Type u_2
β : Type u_1
γ : Type ?u.243948
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
h : Tendsto f l atBot
⊢ Tendsto (fun x => f x * r) l atBot ↔ 0 < r
Theorem: Int.pred_iterate
File: Mathlib/Data/Int/SuccPred.lean

tactic: rw [Function.iterate_succ', Int.ofNat_succ, ← sub_sub]
state_before: a : ℤ
n : ℕ
⊢ (pred^[n + 1]) a = a - ↑(n + 1)

tactic: exact congr_arg _ (pred_iterate a n)
state_before: a : ℤ
n : ℕ
⊢ (pred ∘ pred^[n]) a = a - ↑n - 1
Theorem: Thunk.sizeOf_eq
File: src/lean/Init/Core.lean

tactic: cases a
state_before: α : Type u_1
inst✝ : SizeOf α
a : Thunk α
⊢ sizeOf a = 1 + sizeOf (Thunk.get a)

tactic: rfl
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
fn✝ : Unit → α
⊢ sizeOf { fn := fn✝ } = 1 + sizeOf (Thunk.get { fn := fn✝ })
Theorem: Array.foldr_induction
File: Std/Data/Array/Lemmas.lean

tactic: have := SatisfiesM_foldrM (m := Id) (as := as) (f := f) motive h0
state_before: α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive (size as) init
f : α → β → β
hf : ∀ (i : Fin (size as)) (b : β), motive (i.val + 1) b → motive i.val (f as[i] b)
⊢ motive 0 (foldr f init as (size as))

tactic: simp [SatisfiesM_Id_eq] at this
state_before: α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive (size as) init
f : α → β → β
hf : ∀ (i : Fin (size as)) (b : β), motive (i.val + 1) b → motive i.val (f as[i] b)
this :
  (∀ (i : Fin (size as)) (b : β), motive (i.val + 1) b → SatisfiesM (motive i.val) (f as[i] b)) →
    SatisfiesM (motive 0) (foldrM f init as (size as))
⊢ motive 0 (foldr f init as (size as))

tactic: exact this hf
state_before: α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive (size as) init
f : α → β → β
hf : ∀ (i : Fin (size as)) (b : β), motive (i.val + 1) b → motive i.val (f as[i] b)
this :
  (∀ (i : Fin (size as)) (b : β), motive (i.val + 1) b → motive i.val (f as[i.val] b)) →
    motive 0 (foldrM f init as (size as))
⊢ motive 0 (foldr f init as (size as))
Theorem: RatFunc.liftOn_mk
File: Mathlib/FieldTheory/RatFunc.lean

tactic: by_cases hq : q = 0
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
H :
  optParam (∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
    (_ : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
⊢ RatFunc.liftOn (RatFunc.mk p q) f H = f p q

tactic: subst hq
state_before: case pos
K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
H :
  optParam (∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
    (_ : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
hq : q = 0
⊢ RatFunc.liftOn (RatFunc.mk p q) f H = f p q

tactic: simp only [mk_zero, f0, ← Localization.mk_zero 1, Localization.liftOn_mk,
  liftOn_ofFractionRing_mk, Submonoid.coe_one]
state_before: case pos
K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
H :
  optParam (∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
    (_ : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
⊢ RatFunc.liftOn (RatFunc.mk p 0) f H = f p 0

tactic: simp only [mk_eq_localization_mk _ hq, Localization.liftOn_mk, liftOn_ofFractionRing_mk]
state_before: case neg
K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
H :
  optParam (∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
    (_ : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q')
hq : ¬q = 0
⊢ RatFunc.liftOn (RatFunc.mk p q) f H = f p q
Theorem: Finset.eraseNone_none
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.13019
⊢ ↑eraseNone {none} = ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.13019
a✝ : α
⊢ a✝ ∈ ↑eraseNone {none} ↔ a✝ ∈ ∅
Theorem: orthogonalProjection_norm_le
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: norm_num
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.561143
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
⊢ 0 ≤ 1
Theorem: Pmf.mem_support_uniformOfFinset_iff
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.8867
γ : Type ?u.8870
s : Finset α
hs : Finset.Nonempty s
a✝ a : α
⊢ a ∈ support (uniformOfFinset s hs) ↔ a ∈ s
Theorem: summable_condensed_iff_of_nonneg
File: Mathlib/Analysis/PSeries.lean

tactic: lift f to ℕ → ℝ≥0 using h_nonneg
state_before: f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ (Summable fun k => 2 ^ ↑k * f (2 ^ k)) ↔ Summable f

tactic: simp only [NNReal.coe_le_coe] at *
state_before: case intro
f : ℕ → ℝ≥0
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → (fun i => ↑(f i)) n ≤ (fun i => ↑(f i)) m
⊢ (Summable fun k => 2 ^ ↑k * (fun i => ↑(f i)) (2 ^ k)) ↔ Summable fun i => ↑(f i)

tactic: exact_mod_cast NNReal.summable_condensed_iff h_mono
state_before: case intro
f : ℕ → ℝ≥0
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ (Summable fun k => 2 ^ ↑k * ↑(f (2 ^ k))) ↔ Summable fun i => ↑(f i)
Theorem: Metric.ball_eq_empty
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← not_nonempty_iff_eq_empty, nonempty_ball, not_lt]
state_before: α : Type u
β : Type v
X : Type ?u.25922
ι : Type ?u.25925
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ ball x ε = ∅ ↔ ε ≤ 0
Theorem: Nat.div_mod_unique
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [add_mul_div_left _ _ h, add_mul_mod_self_left]
state_before: m✝ n✝ k✝ n k m d : ℕ
h : 0 < k
x✝ : m + k * d = n ∧ m < k
h₁ : m + k * d = n
h₂ : m < k
⊢ (m + k * d) / k = d ∧ (m + k * d) % k = m

tactic: simp [div_eq_of_lt, mod_eq_of_lt, h₂]
state_before: m✝ n✝ k✝ n k m d : ℕ
h : 0 < k
x✝ : m + k * d = n ∧ m < k
h₁ : m + k * d = n
h₂ : m < k
⊢ m / k + d = d ∧ m % k = m
Theorem: eq_lim_at_right_extendFrom_Ioo
File: Mathlib/Topology/Algebra/Order/ExtendFrom.lean

tactic: apply extendFrom_eq
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : T2Space β
f : α → β
a b : α
lb : β
hab : a < b
hb : Tendsto f (𝓝[Iio b] b) (𝓝 lb)
⊢ extendFrom (Ioo a b) f b = lb

tactic: rw [closure_Ioo hab.ne]
state_before: case hx
α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : T2Space β
f : α → β
a b : α
lb : β
hab : a < b
hb : Tendsto f (𝓝[Iio b] b) (𝓝 lb)
⊢ b ∈ closure (Ioo a b)

tactic: simp only [le_of_lt hab, left_mem_Icc, right_mem_Icc]
state_before: case hx
α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : T2Space β
f : α → β
a b : α
lb : β
hab : a < b
hb : Tendsto f (𝓝[Iio b] b) (𝓝 lb)
⊢ b ∈ Icc a b

tactic: simpa [hab]
state_before: case hf
α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : T2Space β
f : α → β
a b : α
lb : β
hab : a < b
hb : Tendsto f (𝓝[Iio b] b) (𝓝 lb)
⊢ Tendsto f (𝓝[Ioo a b] b) (𝓝 lb)
Theorem: Polynomial.div_tendsto_atBot_of_degree_gt'
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: have hQ : Q ≠ 0 := fun h => by
  simp only [h, div_zero, leadingCoeff_zero] at hneg
  exact hneg.false
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : degree Q < degree P
hneg : leadingCoeff P / leadingCoeff Q < 0
⊢ Tendsto (fun x => eval x P / eval x Q) atTop atBot

tactic: rw [← natDegree_lt_natDegree_iff hQ] at hdeg
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : degree Q < degree P
hneg : leadingCoeff P / leadingCoeff Q < 0
hQ : Q ≠ 0
⊢ Tendsto (fun x => eval x P / eval x Q) atTop atBot

tactic: refine' (isEquivalent_atTop_div P Q).symm.tendsto_atBot _
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : natDegree Q < natDegree P
hneg : leadingCoeff P / leadingCoeff Q < 0
hQ : Q ≠ 0
⊢ Tendsto (fun x => eval x P / eval x Q) atTop atBot

tactic: apply Tendsto.neg_const_mul_atTop hneg
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : natDegree Q < natDegree P
hneg : leadingCoeff P / leadingCoeff Q < 0
hQ : Q ≠ 0
⊢ Tendsto (fun x => leadingCoeff P / leadingCoeff Q * x ^ (↑(natDegree P) - ↑(natDegree Q))) atTop atBot

tactic: apply tendsto_zpow_atTop_atTop
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : natDegree Q < natDegree P
hneg : leadingCoeff P / leadingCoeff Q < 0
hQ : Q ≠ 0
⊢ Tendsto (fun x => x ^ (↑(natDegree P) - ↑(natDegree Q))) atTop atTop

tactic: linarith
state_before: case hn
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : natDegree Q < natDegree P
hneg : leadingCoeff P / leadingCoeff Q < 0
hQ : Q ≠ 0
⊢ 0 < ↑(natDegree P) - ↑(natDegree Q)

tactic: simp only [h, div_zero, leadingCoeff_zero] at hneg
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : degree Q < degree P
hneg : leadingCoeff P / leadingCoeff Q < 0
h : Q = 0
⊢ False

tactic: exact hneg.false
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : degree Q < degree P
h : Q = 0
hneg : 0 < 0
⊢ False
Theorem: Finsupp.equivMapDomain_eq_mapDomain
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext x
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.296865
ι : Type ?u.296868
M✝ : Type ?u.296871
M' : Type ?u.296874
N : Type ?u.296877
P : Type ?u.296880
G : Type ?u.296883
H : Type ?u.296886
R : Type ?u.296889
S : Type ?u.296892
inst✝¹ : AddCommMonoid M✝
v v₁ v₂ : α →₀ M✝
M : Type u_1
inst✝ : AddCommMonoid M
f : α ≃ β
l : α →₀ M
⊢ equivMapDomain f l = mapDomain (↑f) l

tactic: simp [mapDomain_equiv_apply]
state_before: case h
α : Type u_2
β : Type u_3
γ : Type ?u.296865
ι : Type ?u.296868
M✝ : Type ?u.296871
M' : Type ?u.296874
N : Type ?u.296877
P : Type ?u.296880
G : Type ?u.296883
H : Type ?u.296886
R : Type ?u.296889
S : Type ?u.296892
inst✝¹ : AddCommMonoid M✝
v v₁ v₂ : α →₀ M✝
M : Type u_1
inst✝ : AddCommMonoid M
f : α ≃ β
l : α →₀ M
x : β
⊢ ↑(equivMapDomain f l) x = ↑(mapDomain (↑f) l) x
Theorem: NormedAddGroupHom.NormNoninc.zero
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: simp
state_before: V : Type ?u.496737
W : Type ?u.496740
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.496749
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
v : V₁
⊢ ‖↑0 v‖ ≤ ‖v‖
Theorem: CategoryTheory.Limits.biproduct.lift_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: ext
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
⊢ lift k ≫ map p = lift fun j => k j ≫ p j

tactic: simp
state_before: case w
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
j✝ : J
⊢ (lift k ≫ map p) ≫ π (fun b => g b) j✝ = (lift fun j => k j ≫ p j) ≫ π (fun b => g b) j✝
Theorem: HasFDerivAt.unique
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← hasFDerivWithinAt_univ] at h₀ h₁
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.229885
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.229980
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h₀ : HasFDerivAt f f₀' x
h₁ : HasFDerivAt f f₁' x
⊢ f₀' = f₁'

tactic: exact uniqueDiffWithinAt_univ.eq h₀ h₁
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.229885
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.229980
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h₀ : HasFDerivWithinAt f f₀' univ x
h₁ : HasFDerivWithinAt f f₁' univ x
⊢ f₀' = f₁'
Theorem: Matrix.cons_add
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type ?u.58053
n' : Type ?u.58056
o' : Type ?u.58059
inst✝ : Add α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
⊢ vecCons x v + w = vecCons (x + vecHead w) (v + vecTail w)

tactic: refine' Fin.cases _ _ i <;> simp [vecHead, vecTail]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.58053
n' : Type ?u.58056
o' : Type ?u.58059
inst✝ : Add α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ (vecCons x v + w) i = vecCons (x + vecHead w) (v + vecTail w) i
Theorem: SemidirectProduct.rightHom_comp_inl
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext
state_before: N : Type u_1
G : Type u_2
H : Type ?u.105269
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
⊢ MonoidHom.comp rightHom inl = 1

tactic: simp [rightHom]
state_before: case h
N : Type u_1
G : Type u_2
H : Type ?u.105269
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
x✝ : N
⊢ ↑(MonoidHom.comp rightHom inl) x✝ = ↑1 x✝
Theorem: Function.Periodic.sub_nat_mul_eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [nsmul_eq_mul] using h.sub_nsmul_eq n
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.100335
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℕ
⊢ f (x - ↑n * c) = f x
Theorem: Int.exists_unique_equiv_nat
File: Mathlib/Data/Int/ModEq.lean

tactic: constructor <;> rw [ofNat_natAbs_eq_of_nonneg z hz1] <;> assumption
state_before: m n a✝ b✝ c d a b : ℤ
hb : 0 < b
z : ℤ
hz1 : 0 ≤ z
hz2 : z < b
hz3 : z ≡ a [ZMOD b]
⊢ ↑(natAbs z) < b ∧ ↑(natAbs z) ≡ a [ZMOD b]
Theorem: geom_lt
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: apply (monotone_mul_left_of_nonneg hc).seq_pos_lt_seq_of_le_of_lt hn _ _ h
state_before: α : Type ?u.33970
β : Type ?u.33973
ι : Type ?u.33976
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ (k : ℕ), k < n → c * u k < u (k + 1)
⊢ c ^ n * u 0 < u n

tactic: simp
state_before: α : Type ?u.33970
β : Type ?u.33973
ι : Type ?u.33976
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ (k : ℕ), k < n → c * u k < u (k + 1)
⊢ c ^ 0 * u 0 ≤ u 0

tactic: simp [_root_.pow_succ, mul_assoc, le_refl]
state_before: α : Type ?u.33970
β : Type ?u.33973
ι : Type ?u.33976
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ (k : ℕ), k < n → c * u k < u (k + 1)
⊢ ∀ (k : ℕ), k < n → c ^ (k + 1) * u 0 ≤ c * (c ^ k * u 0)
Theorem: Flow.isInvariant_iff_image_eq
File: Mathlib/Dynamics/Flow.lean

tactic: simp [← map_add]
state_before: τ : Type u_2
inst✝³ : AddCommGroup τ
inst✝² : TopologicalSpace τ
inst✝¹ : TopologicalAddGroup τ
α : Type u_1
inst✝ : TopologicalSpace α
ϕ : Flow τ α
s : Set α
h : ∀ (t : τ), toFun ϕ t '' s ⊆ s
t : τ
x✝ : α
hx : x✝ ∈ s
⊢ toFun ϕ t (toFun ϕ (-t) x✝) = x✝

tactic: rw [h t]
state_before: τ : Type u_2
inst✝³ : AddCommGroup τ
inst✝² : TopologicalSpace τ
inst✝¹ : TopologicalAddGroup τ
α : Type u_1
inst✝ : TopologicalSpace α
ϕ : Flow τ α
s : Set α
h : ∀ (t : τ), toFun ϕ t '' s = s
t : τ
⊢ toFun ϕ t '' s ⊆ s
Theorem: inv_zpow'
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [inv_zpow, zpow_neg]
state_before: α : Type u_1
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✝ : DivisionMonoid α
a✝ b a : α
n : ℤ
⊢ a⁻¹ ^ n = a ^ (-n)
Theorem: finprod_mem_finset_product₃
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: classical
  rw [finprod_mem_finset_product']
  simp_rw [finprod_mem_finset_product']
  simp
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.435995
G : Type ?u.435998
M : Type u_4
N : Type ?u.436004
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
γ : Type u_1
s : Finset (α × β × γ)
f : α × β × γ → M
⊢ (∏ᶠ (abc : α × β × γ) (_ : abc ∈ s), f abc) = ∏ᶠ (a : α) (b : β) (c : γ) (_ : (a, b, c) ∈ s), f (a, b, c)

tactic: rw [finprod_mem_finset_product']
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.435995
G : Type ?u.435998
M : Type u_4
N : Type ?u.436004
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
γ : Type u_1
s : Finset (α × β × γ)
f : α × β × γ → M
⊢ (∏ᶠ (abc : α × β × γ) (_ : abc ∈ s), f abc) = ∏ᶠ (a : α) (b : β) (c : γ) (_ : (a, b, c) ∈ s), f (a, b, c)

tactic: simp_rw [finprod_mem_finset_product']
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.435995
G : Type ?u.435998
M : Type u_4
N : Type ?u.436004
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
γ : Type u_1
s : Finset (α × β × γ)
f : α × β × γ → M
⊢ (∏ᶠ (a : α) (b : β × γ) (_ : b ∈ Finset.image Prod.snd (Finset.filter (fun ab => ab.fst = a) s)), f (a, b)) =
    ∏ᶠ (a : α) (b : β) (c : γ) (_ : (a, b, c) ∈ s), f (a, b, c)

tactic: simp
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.435995
G : Type ?u.435998
M : Type u_4
N : Type ?u.436004
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t : Set α
γ : Type u_1
s : Finset (α × β × γ)
f : α × β × γ → M
⊢ (∏ᶠ (a : α) (a_1 : β) (b : γ) (_ :
      b ∈
        Finset.image Prod.snd
          (Finset.filter (fun ab => ab.fst = a_1) (Finset.image Prod.snd (Finset.filter (fun ab => ab.fst = a) s)))),
      f (a, a_1, b)) =
    ∏ᶠ (a : α) (b : β) (c : γ) (_ : (a, b, c) ∈ s), f (a, b, c)
Theorem: IsExposed.inter_left
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: rintro ⟨w, hw⟩
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 A C
hCB : C ⊆ B
⊢ IsExposed 𝕜 (A ∩ B) C

tactic: obtain ⟨l, rfl⟩ := hC ⟨w, hw⟩
state_before: case intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 A C
hCB : C ⊆ B
w : E
hw : w ∈ C
⊢ ∃ l, C = {x | x ∈ A ∩ B ∧ ∀ (y : E), y ∈ A ∩ B → ↑l y ≤ ↑l x}

tactic: exact ⟨l, Subset.antisymm (fun x hx => ⟨⟨hx.1, hCB hx⟩, fun y hy => hx.2 y hy.1⟩)
  fun x ⟨⟨hxC, _⟩, hx⟩ => ⟨hxC, fun y hy => (hw.2 y hy).trans (hx w ⟨hC.subset hw, hCB hw⟩)⟩⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A B : Set E
X : Finset E
x w : E
l : E →L[𝕜] 𝕜
hC : IsExposed 𝕜 A {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}
hCB : {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x} ⊆ B
hw : w ∈ {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}
⊢ ∃ l_1, {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x} = {x | x ∈ A ∩ B ∧ ∀ (y : E), y ∈ A ∩ B → ↑l_1 y ≤ ↑l_1 x}