tasksource/leandojo huggingface dataset:
Theorem: Pell.x_sub_y_dvd_pow
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp [xz, yz, Int.ofNat_zero, Int.ofNat_one]
state_before: a : ℕ
a1 : 1 < a
y : ℕ
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 0 * (↑a - ↑y) + ↑(y ^ 0) - xz a1 0

tactic: simp [xz, yz, Int.ofNat_zero, Int.ofNat_one]
state_before: a : ℕ
a1 : 1 < a
y : ℕ
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 1 * (↑a - ↑y) + ↑(y ^ 1) - xz a1 1

tactic: have : (2 * a * y - y * y - 1 : ℤ) ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) :=
  ⟨-↑(y ^ n), by
    simp [_root_.pow_succ, mul_add, Int.ofNat_mul, show ((2 : ℕ) : ℤ) = 2 from rfl, mul_comm,
      mul_left_comm]
    ring⟩
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 (n + 2) * (↑a - ↑y) + ↑(y ^ (n + 2)) - xz a1 (n + 2)

tactic: rw [xz_succ_succ, yz_succ_succ, x_sub_y_dvd_pow_lem ↑(y ^ (n + 2)) ↑(y ^ (n + 1)) ↑(y ^ n)]
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
this : 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n)
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 (n + 2) * (↑a - ↑y) + ↑(y ^ (n + 2)) - xz a1 (n + 2)

tactic: exact _root_.dvd_sub (dvd_add this <| (x_sub_y_dvd_pow _ (n + 1)).mul_left _)
  (x_sub_y_dvd_pow _ n)
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
this : 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n)
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣
    ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) +
        ↑(2 * a) * (yz a1 (n + 1) * (↑a - ↑y) + ↑(y ^ (n + 1)) - xz a1 (n + 1)) -
      (yz a1 n * (↑a - ↑y) + ↑(y ^ n) - xz a1 n)

tactic: simp [_root_.pow_succ, mul_add, Int.ofNat_mul, show ((2 : ℕ) : ℤ) = 2 from rfl, mul_comm,
  mul_left_comm]
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) = (2 * ↑a * ↑y - ↑y * ↑y - 1) * -↑(y ^ n)

tactic: ring
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ ↑y * (↑y * ↑y ^ n) - ↑a * (↑y * ↑y ^ n * 2) + ↑y ^ n = -(↑y ^ n * (↑a * (↑y * 2) - ↑y * ↑y - 1))
Theorem: Set.mem_diagonal
File: Mathlib/Data/Set/Prod.lean

tactic: simp [diagonal]
state_before: α : Type u_1
s t : Set α
x : α
⊢ (x, x) ∈ diagonal α
Theorem: Set.Ioc_disjoint_Ioc
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: have h : _ ↔ min (toDual a₁) (toDual b₁) ≤ max (toDual a₂) (toDual b₂) := Ico_disjoint_Ico
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
⊢ Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁

tactic: simpa only [dual_Ico] using h
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
h :
  Disjoint (Ico (↑toDual a₂) (↑toDual a₁)) (Ico (↑toDual b₂) (↑toDual b₁)) ↔
    min (↑toDual a₁) (↑toDual b₁) ≤ max (↑toDual a₂) (↑toDual b₂)
⊢ Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁
Theorem: TopologicalSpace.Opens.openEmbedding_of_le
File: Mathlib/Topology/Sets/Opens.lean

tactic: rw [Set.range_inclusion i]
state_before: ι : Type ?u.27267
α : Type u_1
β : Type ?u.27273
γ : Type ?u.27276
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U V : Opens α
i : U ≤ V
⊢ IsOpen (range (inclusion (_ : ↑U ⊆ ↑V)))

tactic: exact U.isOpen.preimage continuous_subtype_val
state_before: ι : Type ?u.27267
α : Type u_1
β : Type ?u.27273
γ : Type ?u.27276
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U V : Opens α
i : U ≤ V
⊢ IsOpen {x | ↑x ∈ ↑U}
Theorem: Prod.smul_zero_mk
File: Mathlib/GroupTheory/GroupAction/Prod.lean

tactic: rw [Prod.smul_mk, smul_zero]
state_before: M : Type u_2
N : Type ?u.1812
P : Type ?u.1815
E : Type ?u.1818
α✝ : Type ?u.1821
β : Type u_3
inst✝⁶ : SMul M α✝
inst✝⁵ : SMul M β
inst✝⁴ : SMul N α✝
inst✝³ : SMul N β
a✝ : M
x : α✝ × β
α : Type u_1
inst✝² : Monoid M
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction M α
a : M
c : β
⊢ a • (0, c) = (0, a • c)
Theorem: Ideal.Quotient.lift_surjective_of_surjective
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: intro y
state_before: R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y : R
inst✝ : CommRing S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hf : Function.Surjective ↑f
⊢ Function.Surjective ↑(lift I f H)

tactic: obtain ⟨x, rfl⟩ := hf y
state_before: R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y✝ : R
inst✝ : CommRing S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hf : Function.Surjective ↑f
y : S
⊢ ∃ a, ↑(lift I f H) a = y

tactic: use Ideal.Quotient.mk I x
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y : R
inst✝ : CommRing S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hf : Function.Surjective ↑f
x : R
⊢ ∃ a, ↑(lift I f H) a = ↑f x

tactic: simp only [Ideal.Quotient.lift_mk]
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y : R
inst✝ : CommRing S
I : Ideal R
f : R →+* S
H : ∀ (a : R), a ∈ I → ↑f a = 0
hf : Function.Surjective ↑f
x : R
⊢ ↑(lift I f H) (↑(mk I) x) = ↑f x
Theorem: Finset.subset_map_iff
File: Mathlib/Data/Finset/Preimage.lean

tactic: refine' ⟨fun h => ⟨_, preimage_subset h, _⟩, _⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α ↪ β
s : Finset β
t : Finset α
⊢ s ⊆ map f t ↔ ∃ u x, s = map f u

tactic: rw [map_eq_image, image_preimage, filter_true_of_mem]
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α ↪ β
s : Finset β
t : Finset α
h : s ⊆ map f t
⊢ s = map f (preimage s ↑f (_ : InjOn (↑f) (↑f ⁻¹' ↑s)))

tactic: exact fun x hx ↦ coe_map_subset_range _ _ (h hx)
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α ↪ β
s : Finset β
t : Finset α
h : s ⊆ map f t
⊢ ∀ (x : β), x ∈ s → x ∈ Set.range ↑f

tactic: rintro ⟨u, hut, rfl⟩
state_before: case refine'_2
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α ↪ β
s : Finset β
t : Finset α
⊢ (∃ u x, s = map f u) → s ⊆ map f t

tactic: exact map_subset_map.2 hut
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α ↪ β
t u : Finset α
hut : u ⊆ t
⊢ map f u ⊆ map f t
Theorem: AffineMap.homothety_isOpenMap
File: Mathlib/Topology/Algebra/Affine.lean

tactic: apply IsOpenMap.of_inverse (homothety_continuous x t⁻¹) <;> intro e <;>
  simp [← AffineMap.comp_apply, ← homothety_mul, ht]
state_before: R : Type u_1
E : Type ?u.20960
F : Type u_2
inst✝⁷ : AddCommGroup E
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup F
inst✝⁴ : TopologicalSpace F
inst✝³ : TopologicalAddGroup F
inst✝² : Field R
inst✝¹ : Module R F
inst✝ : ContinuousConstSMul R F
x : F
t : R
ht : t ≠ 0
⊢ IsOpenMap ↑(homothety x t)
Theorem: Equiv.Perm.mem_finPairsLT
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp only [finPairsLT, Fin.lt_iff_val_lt_val, true_and_iff, mem_attachFin, mem_range, mem_univ,
  mem_sigma]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
a : (_ : Fin n) × Fin n
⊢ a ∈ finPairsLT n ↔ a.snd < a.fst
Theorem: MvPolynomial.mem_degrees
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
simp only [degrees_def, Multiset.mem_sup, ← mem_support_iff, Finsupp.mem_toMultiset, exists_prop]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.44438
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
⊢ i ∈ degrees p ↔ ∃ d, coeff d p ≠ 0 ∧ i ∈ d.support

tactic: simp only [degrees_def, Multiset.mem_sup, ← mem_support_iff, Finsupp.mem_toMultiset, exists_prop]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.44438
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
⊢ i ∈ degrees p ↔ ∃ d, coeff d p ≠ 0 ∧ i ∈ d.support
Theorem: AList.insert_singleton_eq
File: Mathlib/Data/List/AList.lean

tactic: simp only [AList.insert_entries, List.kerase_cons_eq, and_self_iff, AList.singleton_entries,
  heq_iff_eq, eq_self_iff_true]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
⊢ (insert a b (singleton a b')).entries = (singleton a b).entries
Theorem: BoxIntegral.Prepartition.biUnionIndex_le
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: by_cases hJ : J ∈ π.biUnion πi
state_before: ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
J : Box ι
⊢ biUnionIndex π πi J ≤ I

tactic: exact π.le_of_mem (π.biUnionIndex_mem hJ)
state_before: case pos
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
J : Box ι
hJ : J ∈ biUnion π πi
⊢ biUnionIndex π πi J ≤ I

tactic: rw [biUnionIndex, dif_neg hJ]
state_before: case neg
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
J : Box ι
hJ : ¬J ∈ biUnion π πi
⊢ biUnionIndex π πi J ≤ I
Theorem: Stream'.nth_unfolds_head_tail
File: Mathlib/Data/Stream/Init.lean

tactic: intro n
state_before: α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ) (s : Stream' α), nth (unfolds head tail s) n = nth s n

tactic: induction' n with n' ih
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), nth (unfolds head tail s) n = nth s n

tactic: intro s
state_before: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), nth (unfolds head tail s) zero = nth s zero

tactic: rfl
state_before: case zero
α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ nth (unfolds head tail s) zero = nth s zero

tactic: intro s
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), nth (unfolds head tail s) n' = nth s n'
⊢ ∀ (s : Stream' α), nth (unfolds head tail s) (succ n') = nth s (succ n')

tactic: rw [nth_succ, nth_succ, unfolds_eq, tail_cons, ih]
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), nth (unfolds head tail s) n' = nth s n'
s : Stream' α
⊢ nth (unfolds head tail s) (succ n') = nth s (succ n')
Theorem: MeasureTheory.lintegral_nnnorm_zero
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.691697
δ : Type ?u.691700
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
⊢ (∫⁻ (x : α), ↑‖0‖₊ ∂μ) = 0
Theorem: Set.image2_singleton_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_2
α' : Type ?u.22821
β : Type u_3
β' : Type ?u.22827
γ : Type u_1
γ' : Type ?u.22833
δ : Type ?u.22836
δ' : Type ?u.22839
ε : Type ?u.22842
ε' : Type ?u.22845
ζ : Type ?u.22848
ζ' : Type ?u.22851
ν : Type ?u.22854
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
x : γ
⊢ x ∈ image2 f {a} t ↔ x ∈ f a '' t
Theorem: MeasureTheory.snormEssSup_indicator_const_eq
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: refine' le_antisymm (snormEssSup_indicator_const_le s c) _
state_before: α : Type u_1
E : Type ?u.635109
F : Type ?u.635112
G : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s✝ : Set α
hs : MeasurableSet s✝
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hμs : ↑↑μ s ≠ 0
⊢ snormEssSup (Set.indicator s fun x => c) μ = ↑‖c‖₊

tactic: by_contra' h
state_before: α : Type u_1
E : Type ?u.635109
F : Type ?u.635112
G : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s✝ : Set α
hs : MeasurableSet s✝
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hμs : ↑↑μ s ≠ 0
⊢ ↑‖c‖₊ ≤ snormEssSup (Set.indicator s fun x => c) μ

tactic: have h' := ae_iff.mp (ae_lt_of_essSup_lt h)
state_before: α : Type u_1
E : Type ?u.635109
F : Type ?u.635112
G : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s✝ : Set α
hs : MeasurableSet s✝
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hμs : ↑↑μ s ≠ 0
h : snormEssSup (Set.indicator s fun x => c) μ < ↑‖c‖₊
⊢ False

tactic: push_neg  at h'
state_before: α : Type u_1
E : Type ?u.635109
F : Type ?u.635112
G : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s✝ : Set α
hs : MeasurableSet s✝
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hμs : ↑↑μ s ≠ 0
h : snormEssSup (Set.indicator s fun x => c) μ < ↑‖c‖₊
h' : ↑↑μ {a | ¬↑‖Set.indicator s (fun x => c) a‖₊ < ↑‖c‖₊} = 0
⊢ False

tactic: refine' hμs (measure_mono_null (fun x hx_mem => _) h')
state_before: α : Type u_1
E : Type ?u.635109
F : Type ?u.635112
G : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s✝ : Set α
hs : MeasurableSet s✝
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hμs : ↑↑μ s ≠ 0
h : snormEssSup (Set.indicator s fun x => c) μ < ↑‖c‖₊
h' : ↑↑μ {a | ↑‖c‖₊ ≤ ↑‖Set.indicator s (fun x => c) a‖₊} = 0
⊢ False

tactic: rw [Set.mem_setOf_eq, Set.indicator_of_mem hx_mem]
state_before: α : Type u_1
E : Type ?u.635109
F : Type ?u.635112
G : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s✝ : Set α
hs : MeasurableSet s✝
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hμs : ↑↑μ s ≠ 0
h : snormEssSup (Set.indicator s fun x => c) μ < ↑‖c‖₊
h' : ↑↑μ {a | ↑‖c‖₊ ≤ ↑‖Set.indicator s (fun x => c) a‖₊} = 0
x : α
hx_mem : x ∈ s
⊢ x ∈ {a | ↑‖c‖₊ ≤ ↑‖Set.indicator s (fun x => c) a‖₊}
Theorem: MeasureTheory.Measure.prod_zero
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: simp [Measure.prod]
state_before: α : Type u_1
α' : Type ?u.4499304
β : Type u_2
β' : Type ?u.4499310
γ : Type ?u.4499313
E : Type ?u.4499316
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ✝ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ✝
μ : Measure α
⊢ Measure.prod μ 0 = 0
Theorem: deriv_norm_ne_zero
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [*, sq]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a (↑Polynomial.derivative F)‖ = 0
⊢ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 = 0
Theorem: LinearIsometry.norm_toContinuousLinearMap_comp
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simp only [norm_map, coe_toContinuousLinearMap, coe_comp', Function.comp_apply]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_6
Eₗ : Type ?u.3580788
F : Type u_4
Fₗ : Type ?u.3580794
G : Type u_5
Gₗ : Type ?u.3580800
𝓕 : Type ?u.3580803
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedAddCommGroup G
inst✝⁹ : NormedAddCommGroup Fₗ
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NontriviallyNormedField 𝕜₂
inst✝⁶ : NontriviallyNormedField 𝕜₃
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜₃ G
inst✝² : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f✝ g✝ : E →SL[σ₁₂] F
x✝ y z : E
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : RingHomIsometric σ₁₂
f : F →ₛₗᵢ[σ₂₃] G
g : E →SL[σ₁₂] F
x : E
⊢ ‖↑(ContinuousLinearMap.comp (toContinuousLinearMap f) g) x‖ = ‖↑g x‖
Theorem: Finsupp.smul_single_one
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [smul_single, smul_eq_mul, mul_one]
state_before: α : Type u_2
β : Type ?u.645727
γ : Type ?u.645730
ι : Type ?u.645733
M : Type ?u.645736
M' : Type ?u.645739
N : Type ?u.645742
P : Type ?u.645745
G : Type ?u.645748
H : Type ?u.645751
R : Type u_1
S : Type ?u.645757
inst✝ : Semiring R
a : α
b : R
⊢ b • single a 1 = single a b
Theorem: Set.preimage_iterate_eq
File: Mathlib/Data/Set/Image.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type ?u.11434
γ : Type ?u.11437
ι : Sort ?u.11440
ι' : Sort ?u.11443
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
⊢ preimage (f^[n]) = preimage f^[n]

tactic: rw [iterate_succ, iterate_succ', Set.preimage_comp_eq, ih]
state_before: case succ
α : Type u_1
β : Type ?u.11434
γ : Type ?u.11437
ι : Sort ?u.11440
ι' : Sort ?u.11443
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
ih : preimage (f^[n]) = preimage f^[n]
⊢ preimage (f^[Nat.succ n]) = preimage f^[Nat.succ n]

tactic: simp
state_before: case zero
α : Type u_1
β : Type ?u.11434
γ : Type ?u.11437
ι : Sort ?u.11440
ι' : Sort ?u.11443
f✝ : α → β
g : β → γ
f : α → α
⊢ preimage (f^[Nat.zero]) = preimage f^[Nat.zero]
Theorem: Array.get_set
File: Std/Data/Array/Lemmas.lean

tactic: simp [*]
state_before: α : Type ?u.18045
a : Array α
i : Fin (size a)
j : Nat
hj : j < size a
v : α
⊢ j < size (set a i v)

tactic: if h : i.1 = j then subst j; simp [*] else simp [*]
state_before: α : Type u_1
a : Array α
i : Fin (size a)
j : Nat
hj : j < size a
v : α
⊢ (set a i v)[j] = if i.val = j then v else a[j]

tactic: subst j
state_before: α : Type u_1
a : Array α
i : Fin (size a)
j : Nat
hj : j < size a
v : α
h : i.val = j
⊢ (set a i v)[j] = if i.val = j then v else a[j]

tactic: simp [*]
state_before: α : Type u_1
a : Array α
i : Fin (size a)
v : α
hj : i.val < size a
⊢ (set a i v)[i.val] = if i.val = i.val then v else a[i.val]

tactic: simp [*]
state_before: α : Type u_1
a : Array α
i : Fin (size a)
j : Nat
hj : j < size a
v : α
h : ¬i.val = j
⊢ (set a i v)[j] = if i.val = j then v else a[j]
Theorem: bernsteinPolynomial.sum
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: rw [add_pow]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
⊢ ∑ ν in Finset.range (n + 1), bernsteinPolynomial R n ν = (X + (1 - X)) ^ n

tactic: simp only [bernsteinPolynomial, mul_comm, mul_assoc, mul_left_comm]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
⊢ ∑ ν in Finset.range (n + 1), bernsteinPolynomial R n ν =
    ∑ m in Finset.range (n + 1), X ^ m * (1 - X) ^ (n - m) * ↑(choose n m)

tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
⊢ (X + (1 - X)) ^ n = 1
Theorem: Fin.snoc_comp_nat_add
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext i
state_before: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i : Fin n✝
y : α✝ (↑castSucc i)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (m + n) → α
a : α
⊢ snoc f a ∘ ↑(natAdd m) = snoc (f ∘ ↑(natAdd m)) a

tactic: refine' Fin.lastCases _ (fun i ↦ _) i
state_before: case h
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i✝ : Fin n✝
y : α✝ (↑castSucc i✝)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (m + n) → α
a : α
i : Fin (n + 1)
⊢ (snoc f a ∘ ↑(natAdd m)) i = snoc (f ∘ ↑(natAdd m)) a i

tactic: simp only [Function.comp_apply]
state_before: case h.refine'_1
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i✝ : Fin n✝
y : α✝ (↑castSucc i✝)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (m + n) → α
a : α
i : Fin (n + 1)
⊢ (snoc f a ∘ ↑(natAdd m)) (last n) = snoc (f ∘ ↑(natAdd m)) a (last n)

tactic: rw [snoc_last, natAdd_last, snoc_last]
state_before: case h.refine'_1
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i✝ : Fin n✝
y : α✝ (↑castSucc i✝)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (m + n) → α
a : α
i : Fin (n + 1)
⊢ snoc f a (↑(natAdd m) (last n)) = snoc (f ∘ ↑(natAdd m)) a (last n)

tactic: simp only [comp_apply, snoc_castSucc]
state_before: case h.refine'_2
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i✝¹ : Fin n✝
y : α✝ (↑castSucc i✝¹)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (m + n) → α
a : α
i✝ : Fin (n + 1)
i : Fin n
⊢ (snoc f a ∘ ↑(natAdd m)) (↑castSucc i) = snoc (f ∘ ↑(natAdd m)) a (↑castSucc i)

tactic: rw [natAdd_castSucc, snoc_castSucc]
state_before: case h.refine'_2
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i✝¹ : Fin n✝
y : α✝ (↑castSucc i✝¹)
z : α✝ (last n✝)
n m : ℕ
α : Type u_1
f : Fin (m + n) → α
a : α
i✝ : Fin (n + 1)
i : Fin n
⊢ snoc f a (↑(natAdd m) (↑castSucc i)) = f (↑(natAdd m) i)
Theorem: StrictConvex.inter
File: Mathlib/Analysis/Convex/Strict.lean

tactic: intro x hx y hy hxy a b ha hb hab
state_before: 𝕜 : Type u_2
𝕝 : Type ?u.5785
E : Type u_1
F : Type ?u.5791
β : Type ?u.5794
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x y : E
a b : 𝕜
t : Set E
hs : StrictConvex 𝕜 s
ht : StrictConvex 𝕜 t
⊢ StrictConvex 𝕜 (s ∩ t)

tactic: rw [interior_inter]
state_before: 𝕜 : Type u_2
𝕝 : Type ?u.5785
E : Type u_1
F : Type ?u.5791
β : Type ?u.5794
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x✝ y✝ : E
a✝ b✝ : 𝕜
t : Set E
hs : StrictConvex 𝕜 s
ht : StrictConvex 𝕜 t
x : E
hx : x ∈ s ∩ t
y : E
hy : y ∈ s ∩ t
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior (s ∩ t)

tactic: exact ⟨hs hx.1 hy.1 hxy ha hb hab, ht hx.2 hy.2 hxy ha hb hab⟩
state_before: 𝕜 : Type u_2
𝕝 : Type ?u.5785
E : Type u_1
F : Type ?u.5791
β : Type ?u.5794
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x✝ y✝ : E
a✝ b✝ : 𝕜
t : Set E
hs : StrictConvex 𝕜 s
ht : StrictConvex 𝕜 t
x : E
hx : x ∈ s ∩ t
y : E
hy : y ∈ s ∩ t
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior s ∩ interior t