tasksource/leandojo huggingface dataset:
Theorem: Fin.snoc_init_self
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
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)
⊢ snoc (init q) (q (last n)) = q

tactic: by_cases h : j.val < n
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)
j : Fin (n + 1)
⊢ snoc (init q) (q (last n)) j = q j

tactic: simp only [init, snoc, h, cast_eq, dite_true]
state_before: case pos
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)
j : Fin (n + 1)
h : ↑j < n
⊢ snoc (init q) (q (last n)) j = q j

tactic: have _ : castSucc (castLT j h) = j := castSucc_castLT _ _
state_before: case pos
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)
j : Fin (n + 1)
h : ↑j < n
⊢ q (↑castSucc (castLT j (_ : ↑j < n))) = q j

tactic: rw [← cast_eq rfl (q j)]
state_before: case pos
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)
j : Fin (n + 1)
h : ↑j < n
x✝ : ↑castSucc (castLT j h) = j
⊢ q (↑castSucc (castLT j (_ : ↑j < n))) = q j

tactic: congr
state_before: case pos
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)
j : Fin (n + 1)
h : ↑j < n
x✝ : ↑castSucc (castLT j h) = j
⊢ q (↑castSucc (castLT j (_ : ↑j < n))) = _root_.cast (_ : α j = α j) (q j)

tactic: rw [eq_last_of_not_lt h]
state_before: case neg
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)
j : Fin (n + 1)
h : ¬↑j < n
⊢ snoc (init q) (q (last n)) j = q j

tactic: simp
state_before: case neg
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)
j : Fin (n + 1)
h : ¬↑j < n
⊢ snoc (init q) (q (last n)) (last n) = q (last n)
Theorem: disjoint_nhdsSet_nhds
File: Mathlib/Topology/Separation.lean

tactic: have h := (regularSpace_TFAE α).out 0 2
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
⊢ Disjoint (𝓝ˢ s) (𝓝 a) ↔ ¬a ∈ closure s

tactic: exact h.mp ‹_› _ _
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
h : RegularSpace α ↔ ∀ (a : α) (s : Set α), Disjoint (𝓝ˢ s) (𝓝 a) ↔ ¬a ∈ closure s
⊢ Disjoint (𝓝ˢ s) (𝓝 a) ↔ ¬a ∈ closure s
Theorem: Equiv.extendSubtype_apply_of_mem
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: dsimp only [extendSubtype]
state_before: α : Type u_1
β : Type ?u.152201
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : p x
⊢ ↑(extendSubtype e) x = ↑(↑e { val := x, property := hx })

tactic: simp only [subtypeCongr, Equiv.trans_apply, Equiv.sumCongr_apply]
state_before: α : Type u_1
β : Type ?u.152201
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : p x
⊢ ↑(subtypeCongr e (toCompl e)) x = ↑(↑e { val := x, property := hx })

tactic: rw [sumCompl_apply_symm_of_pos _ _ hx, Sum.map_inl, sumCompl_apply_inl]
state_before: α : Type u_1
β : Type ?u.152201
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : p x
⊢ ↑(sumCompl fun x => q x) (Sum.map (↑e) (↑(toCompl e)) (↑(sumCompl fun x => p x).symm x)) =
    ↑(↑e { val := x, property := hx })
Theorem: Subgroup.map_equiv_normalizer_eq
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: ext x
state_before: G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
⊢ map (MulEquiv.toMonoidHom f) (normalizer H) = normalizer (map (MulEquiv.toMonoidHom f) H)

tactic: simp only [mem_normalizer_iff, mem_map_equiv]
state_before: case h
G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
x : N
⊢ x ∈ map (MulEquiv.toMonoidHom f) (normalizer H) ↔ x ∈ normalizer (map (MulEquiv.toMonoidHom f) H)

tactic: rw [f.toEquiv.forall_congr]
state_before: case h
G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
x : N
⊢ (∀ (h : G), h ∈ H ↔ ↑(MulEquiv.symm f) x * h * (↑(MulEquiv.symm f) x)⁻¹ ∈ H) ↔
    ∀ (h : N), ↑(MulEquiv.symm f) h ∈ H ↔ ↑(MulEquiv.symm f) (x * h * x⁻¹) ∈ H

tactic: intro
state_before: case h
G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
x : N
⊢ ∀ {x_1 : G},
    (x_1 ∈ H ↔ ↑(MulEquiv.symm f) x * x_1 * (↑(MulEquiv.symm f) x)⁻¹ ∈ H) ↔
      (↑(MulEquiv.symm f) (↑f.toEquiv x_1) ∈ H ↔ ↑(MulEquiv.symm f) (x * ↑f.toEquiv x_1 * x⁻¹) ∈ H)

tactic: erw [f.toEquiv.symm_apply_apply]
state_before: case h
G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
x : N
x✝ : G
⊢ (x✝ ∈ H ↔ ↑(MulEquiv.symm f) x * x✝ * (↑(MulEquiv.symm f) x)⁻¹ ∈ H) ↔
    (↑(MulEquiv.symm f) (↑f.toEquiv x✝) ∈ H ↔ ↑(MulEquiv.symm f) (x * ↑f.toEquiv x✝ * x⁻¹) ∈ H)

tactic: simp only [map_mul, map_inv]
state_before: case h
G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
x : N
x✝ : G
⊢ (x✝ ∈ H ↔ ↑(MulEquiv.symm f) x * x✝ * (↑(MulEquiv.symm f) x)⁻¹ ∈ H) ↔
    (x✝ ∈ H ↔ ↑(MulEquiv.symm f) (x * ↑f.toEquiv x✝ * x⁻¹) ∈ H)

tactic: erw [f.toEquiv.symm_apply_apply]
state_before: case h
G : Type u_1
G' : Type ?u.627985
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.627994
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ : G →* N
H : Subgroup G
f : G ≃* N
x : N
x✝ : G
⊢ (x✝ ∈ H ↔ ↑(MulEquiv.symm f) x * x✝ * (↑(MulEquiv.symm f) x)⁻¹ ∈ H) ↔
    (x✝ ∈ H ↔ ↑(MulEquiv.symm f) x * ↑(MulEquiv.symm f) (↑f.toEquiv x✝) * (↑(MulEquiv.symm f) x)⁻¹ ∈ H)
Theorem: Mathlib.Tactic.Abel.term_atom_pf
File: Mathlib/Tactic/Abel.lean

tactic: simp [term, h]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
x x' : α
h : x = x'
⊢ x = term 1 x' 0
Theorem: ENNReal.div_lt_of_lt_mul'
File: Mathlib/Data/Real/ENNReal.lean

tactic: rwa [mul_comm]
state_before: α : Type ?u.293833
β : Type ?u.293836
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a < b * c
⊢ a < c * b
Theorem: Finmap.insert_union
File: Mathlib/Data/Finmap.lean

tactic: simp [AList.insert_union]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : Finmap β
a₁ a₂ : AList β
⊢ insert a b (⟦a₁⟧ ∪ ⟦a₂⟧) = insert a b ⟦a₁⟧ ∪ ⟦a₂⟧
Theorem: padicNorm.nonzero
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: rw [padicNorm.eq_zpow_of_nonzero hq]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q ≠ 0
⊢ padicNorm p q ≠ 0

tactic: apply zpow_ne_zero_of_ne_zero
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q ≠ 0
⊢ ↑p ^ (-padicValRat p q) ≠ 0

tactic: exact_mod_cast ne_of_gt hp.1.pos
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q ≠ 0
⊢ ↑p ≠ 0
Theorem: HasDerivAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simpa only [aux] using (hf.hasFDerivAt.cpow hg h0).hasDerivAt
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x c : ℂ
hf : HasDerivAt f f' x
hg : HasDerivAt g g' x
h0 : 0 < (f x).re ∨ (f x).im ≠ 0
⊢ HasDerivAt (fun x => f x ^ g x) (g x * f x ^ (g x - 1) * f' + f x ^ g x * Complex.log (f x) * g') x
Theorem: LucasLehmer.X.left_distrib
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: ext <;> dsimp <;> ring
state_before: q : ℕ+
x y z : X q
⊢ x * (y + z) = x * y + x * z
Theorem: FirstOrder.Language.Term.realize_restrictVar
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction' t with _ _ _ _ ih
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.9538
P : Type ?u.9541
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h : ↑(varFinset t) ⊆ s
v : α → M
⊢ realize (v ∘ Subtype.val) (restrictVar t (Set.inclusion h)) = realize v t

tactic: rfl
state_before: case var
L : Language
L' : Language
M : Type w
N : Type ?u.9538
P : Type ?u.9541
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h✝ : ↑(varFinset t) ⊆ s
v : α → M
_a✝ : α
h : ↑(varFinset (var _a✝)) ⊆ s
⊢ realize (v ∘ Subtype.val) (restrictVar (var _a✝) (Set.inclusion h)) = realize v (var _a✝)

tactic: simp_rw [varFinset, Finset.coe_biUnion, Set.iUnion_subset_iff] at h
state_before: case func
L : Language
L' : Language
M : Type w
N : Type ?u.9538
P : Type ?u.9541
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h✝ : ↑(varFinset t) ⊆ s
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinset (_ts✝ a)) ⊆ s),
    realize (v ∘ Subtype.val) (restrictVar (_ts✝ a) (Set.inclusion h)) = realize v (_ts✝ a)
h : ↑(varFinset (func _f✝ _ts✝)) ⊆ s
⊢ realize (v ∘ Subtype.val) (restrictVar (func _f✝ _ts✝) (Set.inclusion h)) = realize v (func _f✝ _ts✝)

tactic: exact congr rfl (funext fun i => ih i (h i (Finset.mem_univ i)))
state_before: case func
L : Language
L' : Language
M : Type w
N : Type ?u.9538
P : Type ?u.9541
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
t : Term L α
s : Set α
h✝¹ : ↑(varFinset t) ⊆ s
v : α → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinset (_ts✝ a)) ⊆ s),
    realize (v ∘ Subtype.val) (restrictVar (_ts✝ a) (Set.inclusion h)) = realize v (_ts✝ a)
h✝ : ↑(Finset.biUnion Finset.univ fun i => varFinset (_ts✝ i)) ⊆ s
h : ∀ (i : Fin l✝), i ∈ ↑Finset.univ → ↑(varFinset (_ts✝ i)) ⊆ s
⊢ realize (v ∘ Subtype.val) (restrictVar (func _f✝ _ts✝) (Set.inclusion h✝)) = realize v (func _f✝ _ts✝)
Theorem: Set.mulIndicator_comp_of_one
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: funext
state_before: α : Type u_3
β : Type ?u.22458
ι : Type ?u.22461
M : Type u_2
N : Type u_1
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g✝ : α → M
a : α
g : M → N
hg : g 1 = 1
⊢ mulIndicator s (g ∘ f) = g ∘ mulIndicator s f

tactic: simp only [mulIndicator]
state_before: case h
α : Type u_3
β : Type ?u.22458
ι : Type ?u.22461
M : Type u_2
N : Type u_1
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g✝ : α → M
a : α
g : M → N
hg : g 1 = 1
x✝ : α
⊢ mulIndicator s (g ∘ f) x✝ = (g ∘ mulIndicator s f) x✝

tactic: split_ifs <;> simp [*]
state_before: case h
α : Type u_3
β : Type ?u.22458
ι : Type ?u.22461
M : Type u_2
N : Type u_1
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g✝ : α → M
a : α
g : M → N
hg : g 1 = 1
x✝ : α
⊢ (if x✝ ∈ s then (g ∘ f) x✝ else 1) = (g ∘ mulIndicator s f) x✝
Theorem: AlgebraicTopology.DoldKan.PInfty_on_Γ₀_splitting_summand_eq_self
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: rw [PInfty_f]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [n].op) ≫ HomologicalComplex.Hom.f PInfty n =
    Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [n].op)

tactic: rcases n with _|n
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [n].op) ≫ HomologicalComplex.Hom.f (P n) n =
    Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [n].op)

tactic: simpa only [P_f_0_eq] using comp_id _
state_before: case zero
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [Nat.zero].op) ≫
      HomologicalComplex.Hom.f (P Nat.zero) Nat.zero =
    Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [Nat.zero].op)

tactic: exact (HigherFacesVanish.on_Γ₀_summand_id K n).comp_P_eq_self
state_before: case succ
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [Nat.succ n].op) ≫
      HomologicalComplex.Hom.f (P (Nat.succ n)) (Nat.succ n) =
    Splitting.ιSummand (Γ₀.splitting K) (Splitting.IndexSet.id [Nat.succ n].op)
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_smul
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simp only [← ENNReal.coe_eq_coe, BoundedContinuousFunction.coe_smul, testAgainstNN_coe_eq,
  ENNReal.coe_smul]
state_before: Ω : Type u_2
inst✝¹⁰ : MeasurableSpace Ω
R : Type u_1
inst✝⁹ : SMul R ℝ≥0
inst✝⁸ : SMul R ℝ≥0∞
inst✝⁷ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝⁶ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝⁵ : TopologicalSpace Ω
inst✝⁴ : OpensMeasurableSpace Ω
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0
inst✝² : PseudoMetricSpace R
inst✝¹ : Zero R
inst✝ : BoundedSMul R ℝ≥0
μ : FiniteMeasure Ω
c : R
f : Ω →ᵇ ℝ≥0
⊢ testAgainstNN μ (c • f) = c • testAgainstNN μ f

tactic: simp_rw [← smul_one_smul ℝ≥0∞ c (f _ : ℝ≥0∞), ← smul_one_smul ℝ≥0∞ c (lintegral _ _ : ℝ≥0∞),
  smul_eq_mul]
state_before: Ω : Type u_2
inst✝¹⁰ : MeasurableSpace Ω
R : Type u_1
inst✝⁹ : SMul R ℝ≥0
inst✝⁸ : SMul R ℝ≥0∞
inst✝⁷ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝⁶ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝⁵ : TopologicalSpace Ω
inst✝⁴ : OpensMeasurableSpace Ω
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0
inst✝² : PseudoMetricSpace R
inst✝¹ : Zero R
inst✝ : BoundedSMul R ℝ≥0
μ : FiniteMeasure Ω
c : R
f : Ω →ᵇ ℝ≥0
⊢ (∫⁻ (ω : Ω), c • ↑(↑f ω) ∂↑μ) = c • ∫⁻ (ω : Ω), ↑(↑f ω) ∂↑μ

tactic: exact
  @lintegral_const_mul _ _ (μ : Measure Ω) (c • (1 : ℝ≥0∞)) _
    (BoundedContinuousFunction.NNReal.coe_ennreal_comp_measurable f)
state_before: Ω : Type u_2
inst✝¹⁰ : MeasurableSpace Ω
R : Type u_1
inst✝⁹ : SMul R ℝ≥0
inst✝⁸ : SMul R ℝ≥0∞
inst✝⁷ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝⁶ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝⁵ : TopologicalSpace Ω
inst✝⁴ : OpensMeasurableSpace Ω
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0
inst✝² : PseudoMetricSpace R
inst✝¹ : Zero R
inst✝ : BoundedSMul R ℝ≥0
μ : FiniteMeasure Ω
c : R
f : Ω →ᵇ ℝ≥0
⊢ (∫⁻ (ω : Ω), c • 1 * ↑(↑f ω) ∂↑μ) = c • 1 * ∫⁻ (ω : Ω), ↑(↑f ω) ∂↑μ
Theorem: Polynomial.nat_cast_mul_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [← C_eq_nat_cast, C_mul_comp, C_eq_nat_cast]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ comp (↑n * p) r = ↑n * comp p r
Theorem: Quiver.eq_reverse_iff
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

tactic: rw [←reverse_inj, reverse_reverse]
state_before: U : Type ?u.1267
V : Type u_1
W : Type ?u.1273
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
f : a ⟶ b
g : b ⟶ a
⊢ f = reverse g ↔ reverse f = g
Theorem: String.Iterator.ValidFor.pos_eq_zero
File: Std/Data/String/Lemmas.lean

tactic: simp [h.pos, Pos.ext_iff]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.i = 0 ↔ l = []
Theorem: Coheyting.hnot_hnot_sup_boundary
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, sup_inf_left, hnot_sup_self, inf_top_eq, sup_eq_right]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ￢￢a ⊔ ∂ a = a

tactic: exact hnot_hnot_le
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ￢￢a ≤ a
Theorem: CategoryTheory.typesGlue_eval
File: Mathlib/CategoryTheory/Sites/Types.lean

tactic: apply (hs.isSheafFor _ _ (generate_discretePresieve_mem α)).isSeparatedFor.ext
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
⊢ typesGlue S hs α (eval S α s) = s

tactic: intro β f hf
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
⊢ ∀ ⦃Y : Type u⦄ ⦃f : Y ⟶ α⦄, discretePresieve α f → S.map f.op (typesGlue S hs α (eval S α s)) = S.map f.op s

tactic: apply (IsSheafFor.valid_glue _ _ _ hf).trans
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
⊢ S.map f.op (typesGlue S hs α (eval S α s)) = S.map f.op s

tactic: apply (FunctorToTypes.map_comp_apply _ _ _ _).symm.trans
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
⊢ S.map (↾fun x => PUnit.unit).op (eval S α s (f (Classical.choose hf))) = S.map f.op s

tactic: rw [← op_comp]
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
⊢ S.map ((↾fun x => f (Classical.choose hf)).op ≫ (↾fun x => PUnit.unit).op) s = S.map f.op s

tactic: suffices ((↾fun _ ↦ PUnit.unit) ≫ ↾fun _ ↦ f (Classical.choose hf)) = f by rw [this]
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
⊢ S.map ((↾fun x => PUnit.unit) ≫ ↾fun x => f (Classical.choose hf)).op s = S.map f.op s

tactic: funext x
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
⊢ ((↾fun x => PUnit.unit) ≫ ↾fun x => f (Classical.choose hf)) = f

tactic: exact congr_arg f (Classical.choose_spec hf x).symm
state_before: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
x : β
⊢ ((↾fun x => PUnit.unit) ≫ ↾fun x => f (Classical.choose hf)) x = f x

tactic: rw [this]
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
s : S.obj α.op
β : Type u
f : β ⟶ α
hf : discretePresieve α f
this : ((↾fun x => PUnit.unit) ≫ ↾fun x => f (Classical.choose hf)) = f
⊢ S.map ((↾fun x => PUnit.unit) ≫ ↾fun x => f (Classical.choose hf)).op s = S.map f.op s
Theorem: or_rotate
File: Std/Logic.lean

tactic: simp only [or_left_comm, Or.comm]
state_before: a b c : Prop
⊢ a ∨ b ∨ c ↔ b ∨ c ∨ a
Theorem: Fin.cast_val_eq_self
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.eq_iff_veq]
state_before: n✝ m n : ℕ
inst✝ : NeZero n
a : Fin n
⊢ ↑↑a = a

tactic: exact val_cast_of_lt a.isLt
state_before: n✝ m n : ℕ
inst✝ : NeZero n
a : Fin n
⊢ ↑↑↑a = ↑a
Theorem: List.Ico.filter_lt_of_ge
File: Mathlib/Data/List/Intervals.lean

tactic: cases' le_total n l with hnl hln
state_before: n m l : ℕ
hlm : l ≤ m
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n l

tactic: rw [← append_consecutive hnl hlm, filter_append, filter_lt_of_top_le (le_refl l),
  filter_lt_of_le_bot (le_refl l), append_nil]
state_before: case inl
n m l : ℕ
hlm : l ≤ m
hnl : n ≤ l
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n l

tactic: rw [eq_nil_of_le hln, filter_lt_of_le_bot hln]
state_before: case inr
n m l : ℕ
hlm : l ≤ m
hln : l ≤ n
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n l
Theorem: ContDiffBump.tsupport_eq
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: simp_rw [tsupport, f.support_eq, closure_ball _ f.rOut_pos.ne']
state_before: E : Type u_1
X : Type ?u.87643
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
⊢ tsupport ↑f = closedBall c f.rOut
Theorem: Dfinsupp.mk_neg
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [neg_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i : ι
⊢ ↑(mk s (-x)) i = ↑(-mk s x) i

tactic: split_ifs <;> [rfl; rw [neg_zero]]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (-x) { val := i, property := H } else 0) = -if H : i ∈ s then x { val := i, property := H } else 0
Theorem: List.map_filterMap_some_eq_filter_map_is_some
File: Std/Data/List/Lemmas.lean

tactic: induction l <;> simp
state_before: α : Type u_1
β : Type u_2
f : α → Option β
l : List α
⊢ map some (filterMap f l) = filter (fun b => Option.isSome b) (map f l)

tactic: split <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
f : α → Option β
head✝ : α
tail✝ : List α
tail_ih✝ : map some (filterMap f tail✝) = filter (fun b => Option.isSome b) (map f tail✝)
⊢ map some
      (match f head✝ with
      | none => filterMap f tail✝
      | some b => b :: filterMap f tail✝) =
    filter (fun b => Option.isSome b) (f head✝ :: map f tail✝)
Theorem: dense_pi
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [dense_iff_closure_eq, closure_pi_set, pi_congr rfl fun i hi => (hs i hi).closure_eq,
  pi_univ]
state_before: α✝ : Type ?u.272564
β : Type ?u.272567
γ : Type ?u.272570
δ : Type ?u.272573
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
s : (i : ι) → Set (α i)
I : Set ι
hs : ∀ (i : ι), i ∈ I → Dense (s i)
⊢ Dense (Set.pi I s)
Theorem: finsuppTensorFinsupp_single
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

tactic: simp [finsuppTensorFinsupp]
state_before: R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
i : ι
m : M
k : κ
n : N
⊢ ↑(finsuppTensorFinsupp R M N ι κ) (Finsupp.single i m ⊗ₜ[R] Finsupp.single k n) = Finsupp.single (i, k) (m ⊗ₜ[R] n)
Theorem: Cardinal.power_mul
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [mul_comm b c]
state_before: α β : Type u
a b c : Cardinal
⊢ a ^ (b * c) = (a ^ b) ^ c

tactic: exact inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.curry γ β α
state_before: α β : Type u
a b c : Cardinal
⊢ a ^ (c * b) = (a ^ b) ^ c
Theorem: Real.Angle.toReal_eq_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_inj, toReal_pi]
state_before: θ : Angle
⊢ toReal θ = π ↔ θ = ↑π
Theorem: IntervalIntegrable.refl
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: constructor <;> simp
state_before: ι : Type ?u.1621986
𝕜 : Type ?u.1621989
E : Type u_1
F : Type ?u.1621995
A : Type ?u.1621998
inst✝ : NormedAddCommGroup E
f : ℝ → E
a b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
⊢ IntervalIntegrable f μ a a
Theorem: continuous_Prop
File: Mathlib/Topology/Order.lean

tactic: simp only [continuous_iff_continuousAt, ContinuousAt, tendsto_nhds_Prop, isOpen_iff_mem_nhds]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
p : α → Prop
⊢ Continuous p ↔ IsOpen {x | p x}

tactic: rfl
state_before: α : Type u_1
inst✝ : TopologicalSpace α
p : α → Prop
⊢ (∀ (x : α), p x → ∀ᶠ (x : α) in 𝓝 x, p x) ↔ ∀ (a : α), a ∈ {x | p x} → {x | p x} ∈ 𝓝 a