tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_congr_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp_rw [setToSimpleFunc]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.205114
G : Type ?u.205117
𝕜 : Type ?u.205120
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T T' : Set α → E →L[ℝ] F
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α →ₛ E
hf : Integrable ↑f
⊢ setToSimpleFunc T f = setToSimpleFunc T' f

tactic: refine' sum_congr rfl fun x _ => _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.205114
G : Type ?u.205117
𝕜 : Type ?u.205120
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T T' : Set α → E →L[ℝ] F
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α →ₛ E
hf : Integrable ↑f
⊢ ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) x = ∑ x in SimpleFunc.range f, ↑(T' (↑f ⁻¹' {x})) x

tactic: by_cases hx0 : x = 0
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.205114
G : Type ?u.205117
𝕜 : Type ?u.205120
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T T' : Set α → E →L[ℝ] F
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α →ₛ E
hf : Integrable ↑f
x : E
x✝ : x ∈ SimpleFunc.range f
⊢ ↑(T (↑f ⁻¹' {x})) x = ↑(T' (↑f ⁻¹' {x})) x

tactic: simp [hx0]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.205114
G : Type ?u.205117
𝕜 : Type ?u.205120
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T T' : Set α → E →L[ℝ] F
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α →ₛ E
hf : Integrable ↑f
x : E
x✝ : x ∈ SimpleFunc.range f
hx0 : x = 0
⊢ ↑(T (↑f ⁻¹' {x})) x = ↑(T' (↑f ⁻¹' {x})) x

tactic: rw [h (f ⁻¹' {x}) (SimpleFunc.measurableSet_fiber _ _)
    (SimpleFunc.measure_preimage_lt_top_of_integrable _ hf hx0)]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.205114
G : Type ?u.205117
𝕜 : Type ?u.205120
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T T' : Set α → E →L[ℝ] F
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = T' s
f : α →ₛ E
hf : Integrable ↑f
x : E
x✝ : x ∈ SimpleFunc.range f
hx0 : ¬x = 0
⊢ ↑(T (↑f ⁻¹' {x})) x = ↑(T' (↑f ⁻¹' {x})) x
Theorem: Finset.card_union_add_card_inter
File: Mathlib/Data/Finset/Card.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.31550
s✝ t✝ : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
s t : Finset α
⊢ card (s ∪ ∅) + card (s ∩ ∅) = card s + card ∅

tactic: by_cases a ∈ s <;>
simp [*, ← add_assoc, add_right_comm _ 1]
state_before: α : Type u_1
β : Type ?u.31550
s✝ t✝ : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
s t : Finset α
a : α
r : Finset α
har : ¬a ∈ r
h : card (s ∪ r) + card (s ∩ r) = card s + card r
⊢ card (s ∪ insert a r) + card (s ∩ insert a r) = card s + card (insert a r)
Theorem: List.dlookup_kunion_right
File: Mathlib/Data/List/Sigma.lean

tactic: induction l₁ generalizing l₂
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
h : ¬a ∈ keys l₁
⊢ dlookup a (kunion l₁ l₂) = dlookup a l₂

tactic: case nil => simp
state_before: case nil
α : Type u
β : α → Type v
l l₁ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₂ : List (Sigma β)
h : ¬a ∈ keys []
⊢ dlookup a (kunion [] l₂) = dlookup a l₂

case cons
α : Type u
β : α → Type v
l l₁ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
tail_ih✝ : ∀ {l₂ : List (Sigma β)}, ¬a ∈ keys tail✝ → dlookup a (kunion tail✝ l₂) = dlookup a l₂
l₂ : List (Sigma β)
h : ¬a ∈ keys (head✝ :: tail✝)
⊢ dlookup a (kunion (head✝ :: tail✝) l₂) = dlookup a l₂

tactic: case cons _ _ ih => simp [not_or] at h; simp [h.1, ih h.2]
state_before: case cons
α : Type u
β : α → Type v
l l₁ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
tail_ih✝ : ∀ {l₂ : List (Sigma β)}, ¬a ∈ keys tail✝ → dlookup a (kunion tail✝ l₂) = dlookup a l₂
l₂ : List (Sigma β)
h : ¬a ∈ keys (head✝ :: tail✝)
⊢ dlookup a (kunion (head✝ :: tail✝) l₂) = dlookup a l₂

tactic: simp
state_before: α : Type u
β : α → Type v
l l₁ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₂ : List (Sigma β)
h : ¬a ∈ keys []
⊢ dlookup a (kunion [] l₂) = dlookup a l₂

tactic: simp [not_or] at h
state_before: α : Type u
β : α → Type v
l l₁ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : ∀ {l₂ : List (Sigma β)}, ¬a ∈ keys tail✝ → dlookup a (kunion tail✝ l₂) = dlookup a l₂
l₂ : List (Sigma β)
h : ¬a ∈ keys (head✝ :: tail✝)
⊢ dlookup a (kunion (head✝ :: tail✝) l₂) = dlookup a l₂

tactic: simp [h.1, ih h.2]
state_before: α : Type u
β : α → Type v
l l₁ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : ∀ {l₂ : List (Sigma β)}, ¬a ∈ keys tail✝ → dlookup a (kunion tail✝ l₂) = dlookup a l₂
l₂ : List (Sigma β)
h : ¬a = head✝.fst ∧ ¬a ∈ keys tail✝
⊢ dlookup a (kunion (head✝ :: tail✝) l₂) = dlookup a l₂
Theorem: linearIndependent_inl_union_inr'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: refine' isCompl_range_inl_inr.disjoint.mono _ _ <;>
  simp only [span_le, range_coe, range_comp_subset_range]
state_before: ι : Type u'
ι' : Type u_3
R : Type u_1
K : Type ?u.650261
M : Type u_2
M' : Type u_4
M'' : Type ?u.650270
V : Type u
V' : Type ?u.650275
v✝ : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
v : ι → M
v' : ι' → M'
hv : LinearIndependent R v
hv' : LinearIndependent R v'
⊢ Disjoint (span R (Set.range (↑(inl R M M') ∘ v))) (span R (Set.range (↑(inr R M M') ∘ v')))
Theorem: Affine.Simplex.reindex_symm_reindex
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [← reindex_trans, Equiv.symm_trans_self, reindex_refl]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
m n : ℕ
s : Simplex k P m
e : Fin (n + 1) ≃ Fin (m + 1)
⊢ reindex (reindex s e.symm) e = s
Theorem: MeasureTheory.SimpleFunc.lintegral_eq_lintegral
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [MeasureTheory.lintegral]
state_before: α : Type u_1
β : Type ?u.69212
γ : Type ?u.69215
δ : Type ?u.69218
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α →ₛ ℝ≥0∞
μ : Measure α
⊢ (∫⁻ (a : α), ↑f a ∂μ) = lintegral f μ

tactic: exact
  le_antisymm (iSup₂_le fun g hg => lintegral_mono hg <| le_rfl) (le_iSup₂_of_le f le_rfl le_rfl)
state_before: α : Type u_1
β : Type ?u.69212
γ : Type ?u.69215
δ : Type ?u.69218
m✝ : MeasurableSpace α
μ✝ ν : Measure α
m : MeasurableSpace α
f : α →ₛ ℝ≥0∞
μ : Measure α
⊢ (⨆ (g : α →ₛ ℝ≥0∞) (_ : ↑g ≤ fun a => ↑f a), lintegral g μ) = lintegral f μ
Theorem: Set.inter_biInter
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [inter_comm, ← biInter_inter hs]
state_before: α✝ : Type ?u.105347
β : Type ?u.105350
γ : Type ?u.105353
ι✝ : Sort ?u.105356
ι' : Sort ?u.105359
ι₂ : Sort ?u.105362
κ : ι✝ → Sort ?u.105367
κ₁ : ι✝ → Sort ?u.105372
κ₂ : ι✝ → Sort ?u.105377
κ' : ι' → Sort ?u.105382
ι : Type u_1
α : Type u_2
s : Set ι
hs : Set.Nonempty s
f : ι → Set α
t : Set α
⊢ (⋂ (i : ι) (_ : i ∈ s), t ∩ f i) = t ∩ ⋂ (i : ι) (_ : i ∈ s), f i

tactic: simp [inter_comm]
state_before: α✝ : Type ?u.105347
β : Type ?u.105350
γ : Type ?u.105353
ι✝ : Sort ?u.105356
ι' : Sort ?u.105359
ι₂ : Sort ?u.105362
κ : ι✝ → Sort ?u.105367
κ₁ : ι✝ → Sort ?u.105372
κ₂ : ι✝ → Sort ?u.105377
κ' : ι' → Sort ?u.105382
ι : Type u_1
α : Type u_2
s : Set ι
hs : Set.Nonempty s
f : ι → Set α
t : Set α
⊢ (⋂ (i : ι) (_ : i ∈ s), t ∩ f i) = ⋂ (i : ι) (_ : i ∈ s), f i ∩ t
Theorem: ProbabilityTheory.IndepSets.symm
File: Mathlib/Probability/Independence/Basic.lean

tactic: intro t1 t2 ht1 ht2
state_before: Ω : Type u_1
ι : Type ?u.432097
s₁ s₂ : Set (Set Ω)
inst✝ : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
h : IndepSets s₁ s₂
⊢ IndepSets s₂ s₁

tactic: rw [Set.inter_comm, mul_comm]
state_before: Ω : Type u_1
ι : Type ?u.432097
s₁ s₂ : Set (Set Ω)
inst✝ : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
h : IndepSets s₁ s₂
t1 t2 : Set Ω
ht1 : t1 ∈ s₂
ht2 : t2 ∈ s₁
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: exact h t2 t1 ht2 ht1
state_before: Ω : Type u_1
ι : Type ?u.432097
s₁ s₂ : Set (Set Ω)
inst✝ : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
h : IndepSets s₁ s₂
t1 t2 : Set Ω
ht1 : t1 ∈ s₂
ht2 : t2 ∈ s₁
⊢ ↑↑μ (t2 ∩ t1) = ↑↑μ t2 * ↑↑μ t1
Theorem: Polynomial.isLocalRingHom_expand
File: Mathlib/Data/Polynomial/Expand.lean

tactic: refine' ⟨fun f hf1 => _⟩
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
⊢ IsLocalRingHom ↑(expand R p)

tactic: norm_cast at hf1
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit (↑↑(expand R p) f)
⊢ IsUnit f

tactic: have hf2 := eq_C_of_degree_eq_zero (degree_eq_zero_of_isUnit hf1)
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit (↑(expand R p) f)
⊢ IsUnit f

tactic: rw [coeff_expand hp, if_pos (dvd_zero _), p.zero_div] at hf2
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit (↑(expand R p) f)
hf2 : ↑(expand R p) f = ↑C (coeff (↑(expand R p) f) 0)
⊢ IsUnit f

tactic: rw [hf2, isUnit_C] at hf1
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit (↑(expand R p) f)
hf2 : ↑(expand R p) f = ↑C (coeff f 0)
⊢ IsUnit f

tactic: rw [expand_eq_C hp] at hf2
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit (coeff f 0)
hf2 : ↑(expand R p) f = ↑C (coeff f 0)
⊢ IsUnit f

tactic: rwa [hf2, isUnit_C]
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit (coeff f 0)
hf2 : f = ↑C (coeff f 0)
⊢ IsUnit f
Theorem: Cubic.disc_ne_zero_iff_roots_nodup
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [disc_ne_zero_iff_roots_ne ha h3, h3]
state_before: R : Type ?u.1296918
S : Type ?u.1296921
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ disc P ≠ 0 ↔ Nodup (roots (map φ P))

tactic: change _ ↔ (x ::ₘ y ::ₘ {z}).Nodup
state_before: R : Type ?u.1296918
S : Type ?u.1296921
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ Nodup {x, y, z}

tactic: rw [nodup_cons, nodup_cons, mem_cons, mem_singleton, mem_singleton]
state_before: R : Type ?u.1296918
S : Type ?u.1296921
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ Nodup (x ::ₘ y ::ₘ {z})

tactic: simp only [nodup_singleton]
state_before: R : Type ?u.1296918
S : Type ?u.1296921
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ ¬(x = y ∨ x = z) ∧ ¬y = z ∧ Nodup {z}

tactic: tauto
state_before: R : Type ?u.1296918
S : Type ?u.1296921
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ ¬(x = y ∨ x = z) ∧ ¬y = z ∧ True
Theorem: MultilinearMap.mkPiRing_apply_one_eq_self
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext m
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f✝ f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
f : MultilinearMap R (fun x => R) M₂
⊢ MultilinearMap.mkPiRing R ι (↑f fun x => 1) = f

tactic: have : m = fun i => m i • (1 : R) := by
  ext j
  simp
state_before: case H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f✝ f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
f : MultilinearMap R (fun x => R) M₂
m : ι → R
⊢ ↑(MultilinearMap.mkPiRing R ι (↑f fun x => 1)) m = ↑f m

tactic: conv_rhs => rw [this, f.map_smul_univ]
state_before: case H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f✝ f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
f : MultilinearMap R (fun x => R) M₂
m : ι → R
this : m = fun i => m i • 1
⊢ ↑(MultilinearMap.mkPiRing R ι (↑f fun x => 1)) m = ↑f m

tactic: ext j
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f✝ f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
f : MultilinearMap R (fun x => R) M₂
m : ι → R
⊢ m = fun i => m i • 1

tactic: simp
state_before: case h
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f✝ f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
f : MultilinearMap R (fun x => R) M₂
m : ι → R
j : ι
⊢ m j = m j • 1
Theorem: IsometryEquiv.preimage_sphere
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.isometry.preimage_sphere (h.symm x) r, h.apply_symm_apply]
state_before: ι : Type ?u.1073874
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : β
r : ℝ
⊢ ↑h ⁻¹' Metric.sphere x r = Metric.sphere (↑(IsometryEquiv.symm h) x) r
Theorem: FractionalIdeal.canonicalEquiv_canonicalEquiv
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: ext
state_before: R : Type u_2
inst✝⁹ : CommRing R
S : Submonoid R
P : Type u_3
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
P' : Type u_4
inst✝⁶ : CommRing P'
inst✝⁵ : Algebra R P'
loc' : IsLocalization S P'
P''✝ : Type ?u.928438
inst✝⁴ : CommRing P''✝
inst✝³ : Algebra R P''✝
loc'' : IsLocalization S P''✝
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
P'' : Type u_1
inst✝² : CommRing P''
inst✝¹ : Algebra R P''
inst✝ : IsLocalization S P''
I : FractionalIdeal S P
⊢ ↑(canonicalEquiv S P' P'') (↑(canonicalEquiv S P P') I) = ↑(canonicalEquiv S P P'') I

tactic: simp only [IsLocalization.map_map, RingHomInvPair.comp_eq₂, mem_canonicalEquiv_apply,
  exists_prop, exists_exists_and_eq_and]
state_before: case a
R : Type u_2
inst✝⁹ : CommRing R
S : Submonoid R
P : Type u_3
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
P' : Type u_4
inst✝⁶ : CommRing P'
inst✝⁵ : Algebra R P'
loc' : IsLocalization S P'
P''✝ : Type ?u.928438
inst✝⁴ : CommRing P''✝
inst✝³ : Algebra R P''✝
loc'' : IsLocalization S P''✝
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
P'' : Type u_1
inst✝² : CommRing P''
inst✝¹ : Algebra R P''
inst✝ : IsLocalization S P''
I : FractionalIdeal S P
x✝ : P''
⊢ x✝ ∈ ↑(canonicalEquiv S P' P'') (↑(canonicalEquiv S P P') I) ↔ x✝ ∈ ↑(canonicalEquiv S P P'') I
Theorem: Real.logb_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp_rw [logb, div_eq_zero_iff, log_eq_zero]
state_before: b x y : ℝ
⊢ logb b x = 0 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1

tactic: tauto
state_before: b x y : ℝ
⊢ (x = 0 ∨ x = 1 ∨ x = -1) ∨ b = 0 ∨ b = 1 ∨ b = -1 ↔ b = 0 ∨ b = 1 ∨ b = -1 ∨ x = 0 ∨ x = 1 ∨ x = -1
Theorem: Complex.arg_neg_eq_arg_sub_pi_of_im_pos
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [arg_of_im_pos hi, arg_of_im_neg (show (-x).im < 0 from Left.neg_neg_iff.2 hi)]
state_before: x : ℂ
hi : 0 < x.im
⊢ arg (-x) = arg x - π

tactic: simp [neg_div, Real.arccos_neg]
state_before: x : ℂ
hi : 0 < x.im
⊢ -arccos ((-x).re / ↑abs (-x)) = arccos (x.re / ↑abs x) - π
Theorem: Polynomial.iterate_derivative_int_cast_mul
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: induction' k with k ih generalizing f <;> simp [*]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Ring R
n : ℤ
k : ℕ
f : R[X]
⊢ (↑derivative^[k]) (↑n * f) = ↑n * (↑derivative^[k]) f
Theorem: PowerSeries.order_add_of_order_eq.aux
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: suffices order (φ + ψ) = order φ by
  rw [le_inf_iff, this]
  exact ⟨le_rfl, le_of_lt H⟩
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
⊢ order (φ + ψ) ≤ order φ ⊓ order ψ

tactic: rw [le_inf_iff, this]
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
this : order (φ + ψ) = order φ
⊢ order (φ + ψ) ≤ order φ ⊓ order ψ

tactic: exact ⟨le_rfl, le_of_lt H⟩
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
this : order (φ + ψ) = order φ
⊢ order φ ≤ order φ ∧ order φ ≤ order ψ

tactic: rw [order_eq]
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
⊢ order (φ + ψ) = order φ

tactic: constructor
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
⊢ (∀ (i : ℕ), ↑i = order φ → ↑(coeff R i) (φ + ψ) ≠ 0) ∧ ∀ (i : ℕ), ↑i < order φ → ↑(coeff R i) (φ + ψ) = 0

tactic: intro i hi
state_before: case left
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
⊢ ∀ (i : ℕ), ↑i = order φ → ↑(coeff R i) (φ + ψ) ≠ 0

tactic: rw [← hi] at H
state_before: case left
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
i : ℕ
hi : ↑i = order φ
⊢ ↑(coeff R i) (φ + ψ) ≠ 0

tactic: rw [(coeff _ _).map_add, coeff_of_lt_order i H, add_zero]
state_before: case left
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
i : ℕ
H : ↑i < order ψ
hi : ↑i = order φ
⊢ ↑(coeff R i) (φ + ψ) ≠ 0

tactic: exact (order_eq_nat.1 hi.symm).1
state_before: case left
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
i : ℕ
H : ↑i < order ψ
hi : ↑i = order φ
⊢ ↑(coeff R i) φ ≠ 0

tactic: intro i hi
state_before: case right
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
⊢ ∀ (i : ℕ), ↑i < order φ → ↑(coeff R i) (φ + ψ) = 0

tactic: rw [(coeff _ _).map_add, coeff_of_lt_order i hi, coeff_of_lt_order i (lt_trans hi H),
  zero_add]
state_before: case right
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : PowerSeries R
_h : order φ ≠ order ψ
H : order φ < order ψ
i : ℕ
hi : ↑i < order φ
⊢ ↑(coeff R i) (φ + ψ) = 0
Theorem: Polynomial.degree_cubic
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [add_assoc, add_assoc, ← add_assoc (C b * X ^ 2),
  degree_add_eq_left_of_degree_lt <| degree_quadratic_lt_degree_C_mul_X_cb ha,
  degree_C_mul_X_pow 3 ha]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.1382528
ha : a ≠ 0
⊢ degree (↑C a * X ^ 3 + ↑C b * X ^ 2 + ↑C c * X + ↑C d) = 3

tactic: rfl
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.1382528
ha : a ≠ 0
⊢ ↑3 = 3
Theorem: CompactExhaustion.mem_diff_shiftr_find
File: Mathlib/Topology/SubsetProperties.lean

tactic: simp only [find_shiftr, not_le, Nat.lt_succ_self]
state_before: α : Type u
β : Type v
ι : Type ?u.169884
π : ι → Type ?u.169889
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
K : CompactExhaustion α
x : α
⊢ ¬CompactExhaustion.find (shiftr K) x ≤ CompactExhaustion.find K x
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp [setToSimpleFunc]
state_before: α : Type u_1
E : Type ?u.125421
F : Type u_2
F' : Type u_3
G : Type ?u.125430
𝕜 : Type ?u.125433
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
f : α →ₛ F
⊢ setToSimpleFunc 0 f = 0
Theorem: Pell.asq_pos
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have := @Nat.mul_le_mul_left 1 a a (le_of_lt a1)
state_before: a : ℕ
a1 : 1 < a
⊢ a ≤ a * a

tactic: rwa [mul_one] at this
state_before: a : ℕ
a1 : 1 < a
this : a * 1 ≤ a * a
⊢ a ≤ a * a
Theorem: Order.pred_eq_iff_covby
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
⊢ pred b = a → a ⋖ b

tactic: exact pred_covby _
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
b : α
inst✝ : NoMinOrder α
⊢ pred b ⋖ b
Theorem: DiscreteValuationRing.ofHasUnitMulPowIrreducibleFactorization
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: letI : UniqueFactorizationMonoid R := hR.toUniqueFactorizationMonoid
state_before: R✝ : Type ?u.108992
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
hR : HasUnitMulPowIrreducibleFactorization R
⊢ DiscreteValuationRing R

tactic: apply of_ufd_of_unique_irreducible _ hR.unique_irreducible
state_before: R✝ : Type ?u.108992
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
hR : HasUnitMulPowIrreducibleFactorization R
this : UniqueFactorizationMonoid R := HasUnitMulPowIrreducibleFactorization.toUniqueFactorizationMonoid hR
⊢ DiscreteValuationRing R

tactic: obtain ⟨p, hp, H⟩ := hR
state_before: R✝ : Type ?u.108992
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
hR : HasUnitMulPowIrreducibleFactorization R
this : UniqueFactorizationMonoid R := HasUnitMulPowIrreducibleFactorization.toUniqueFactorizationMonoid hR
⊢ ∃ p, Irreducible p

tactic: exact ⟨p, hp⟩
state_before: case intro.intro
R✝ : Type ?u.108992
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R
hp : Irreducible p
H : ∀ {x : R}, x ≠ 0 → ∃ n, Associated (p ^ n) x
this : UniqueFactorizationMonoid R :=
  HasUnitMulPowIrreducibleFactorization.toUniqueFactorizationMonoid (Exists.intro p { left := hp, right := H })
⊢ ∃ p, Irreducible p