tasksource/leandojo huggingface dataset:
Theorem: Decidable.and_or_imp
File: Std/Logic.lean

tactic: simp only [ha, true_and, true_imp_iff]
state_before: a b c : Prop
inst✝ : Decidable a
ha : a
⊢ a ∧ b ∨ (a → c) ↔ a → b ∨ c

tactic: simp only [ha, false_or, false_and, false_imp_iff]
state_before: a b c : Prop
inst✝ : Decidable a
ha : ¬a
⊢ a ∧ b ∨ (a → c) ↔ a → b ∨ c
Theorem: Thunk.ext
File: Mathlib/Data/LazyList/Basic.lean

tactic: have ⟨_⟩ := a
state_before: α : Type u
a b : Thunk α
eq : Thunk.get a = Thunk.get b
⊢ a = b

tactic: have ⟨_⟩ := b
state_before: α : Type u
a b : Thunk α
fn✝ : Unit → α
eq : Thunk.get { fn := fn✝ } = Thunk.get b
⊢ { fn := fn✝ } = b

tactic: congr
state_before: α : Type u
a b : Thunk α
fn✝¹ fn✝ : Unit → α
eq : Thunk.get { fn := fn✝¹ } = Thunk.get { fn := fn✝ }
⊢ { fn := fn✝¹ } = { fn := fn✝ }

tactic: exact funext fun _ ↦ eq
state_before: case e_fn
α : Type u
a b : Thunk α
fn✝¹ fn✝ : Unit → α
eq : Thunk.get { fn := fn✝¹ } = Thunk.get { fn := fn✝ }
⊢ fn✝¹ = fn✝
Theorem: Finset.exists_lt_card_fiber_of_nsmul_lt_card_of_maps_to
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simp_rw [cast_card] at ht⊢
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : card t • b < ↑(card s)
⊢ ∃ y, y ∈ t ∧ b < ↑(card (filter (fun x => f x = y) s))

tactic: exact exists_lt_sum_fiber_of_maps_to_of_nsmul_lt_sum hf ht
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : card t • b < ∑ a in s, 1
⊢ ∃ y, y ∈ t ∧ b < ∑ a in filter (fun x => f x = y) s, 1
Theorem: Function.Embedding.invOfMemRange_surjective
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.73841
inst✝¹ : Fintype α
inst✝ : DecidableEq β
f : α ↪ β
b : ↑(Set.range ↑f)
a : α
⊢ invOfMemRange f { val := ↑f a, property := (_ : ↑f a ∈ Set.range ↑f) } = a
Theorem: Primrec.to_comp
File: Mathlib/Computability/Partrec.lean

tactic: simp
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → σ
hf : Primrec f
n : ℕ
⊢ (do
      let n ← (↑fun n => encode (Option.map f (decode n))) n
      ↑(Nat.ppred n)) =
    Part.bind ↑(decode n) fun a => map encode (↑f a)

tactic: cases decode (α := α) n <;> simp
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → σ
hf : Primrec f
n : ℕ
⊢ ↑(Nat.ppred (encode (Option.map f (decode n)))) = Part.bind ↑(decode n) fun a => Part.some (encode (f a))
Theorem: Set.Finite.isCompact_convexHull
File: Mathlib/Analysis/Convex/Topology.lean

tactic: rw [hs.convexHull_eq_image]
state_before: ι : Type ?u.158241
𝕜 : Type ?u.158244
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : Set.Finite s
⊢ IsCompact (↑(convexHull ℝ).toOrderHom s)

tactic: apply (@isCompact_stdSimplex _ hs.fintype).image
state_before: ι : Type ?u.158241
𝕜 : Type ?u.158244
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : Set.Finite s
⊢ IsCompact (↑(Finset.sum Finset.univ fun x => LinearMap.smulRight (LinearMap.proj x) ↑x) '' stdSimplex ℝ ↑s)

tactic: haveI := hs.fintype
state_before: ι : Type ?u.158241
𝕜 : Type ?u.158244
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : Set.Finite s
⊢ Continuous ↑(Finset.sum Finset.univ fun x => LinearMap.smulRight (LinearMap.proj x) ↑x)

tactic: apply LinearMap.continuous_on_pi
state_before: ι : Type ?u.158241
𝕜 : Type ?u.158244
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : Set.Finite s
this : Fintype ↑s
⊢ Continuous ↑(Finset.sum Finset.univ fun x => LinearMap.smulRight (LinearMap.proj x) ↑x)
Theorem: Polynomial.roots_map
File: Mathlib/Data/Polynomial/Splits.lean

tactic: convert(natDegree_eq_card_roots hf).symm
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits (RingHom.id K) f
⊢ ↑Multiset.card (roots f) = natDegree f

tactic: rw [map_id]
state_before: case h.e'_2.h.e'_6.h.e'_4
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits (RingHom.id K) f
⊢ f = map (RingHom.id K) f
Theorem: circleIntegral.integral_sub
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [circleIntegral, smul_sub, intervalIntegral.integral_sub hf.out hg.out]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f g : ℂ → E
c : ℂ
R : ℝ
hf : CircleIntegrable f c R
hg : CircleIntegrable g c R
⊢ (∮ (z : ℂ) in C(c, R), f z - g z) = (∮ (z : ℂ) in C(c, R), f z) - ∮ (z : ℂ) in C(c, R), g z
Theorem: CategoryTheory.Limits.limit.pre_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: erw [IsLimit.fac]
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ pre F E ≫ π (E ⋙ F) k = π F (E.obj k)

tactic: rfl
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ (Cone.whisker E (cone F)).π.app k = π F (E.obj k)
Theorem: MeasureTheory.subset_toMeasurable
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [toMeasurable_def]
state_before: α : Type u_1
β : Type ?u.141314
γ : Type ?u.141317
δ : Type ?u.141320
ι : Type ?u.141323
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
⊢ s ⊆ toMeasurable μ s

tactic: split_ifs with hs h's
state_before: α : Type u_1
β : Type ?u.141314
γ : Type ?u.141317
δ : Type ?u.141320
ι : Type ?u.141323
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
⊢ s ⊆
    if h : ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s then Exists.choose h
    else
      if h' : ∃ t x, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → ↑↑μ (t ∩ u) = ↑↑μ (s ∩ u) then Exists.choose h'
      else Exists.choose (_ : ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = ↑↑μ s)

tactic: exacts [hs.choose_spec.fst, h's.choose_spec.fst, (exists_measurable_superset μ s).choose_spec.1]
state_before: case inl
α : Type u_1
β : Type ?u.141314
γ : Type ?u.141317
δ : Type ?u.141320
ι : Type ?u.141323
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
hs : ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
⊢ s ⊆ Exists.choose hs

case inr.inl
α : Type u_1
β : Type ?u.141314
γ : Type ?u.141317
δ : Type ?u.141320
ι : Type ?u.141323
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
hs : ¬∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
h's : ∃ t x, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → ↑↑μ (t ∩ u) = ↑↑μ (s ∩ u)
⊢ s ⊆ Exists.choose h's

case inr.inr
α : Type u_1
β : Type ?u.141314
γ : Type ?u.141317
δ : Type ?u.141320
ι : Type ?u.141323
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
hs : ¬∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
h's : ¬∃ t x, MeasurableSet t ∧ ∀ (u : Set α), MeasurableSet u → ↑↑μ (t ∩ u) = ↑↑μ (s ∩ u)
⊢ s ⊆ Exists.choose (_ : ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = ↑↑μ s)
Theorem: AddMonoidAlgebra.single_mem_gradeBy
File: Mathlib/Algebra/MonoidAlgebra/Grading.lean

tactic: intro x hx
state_before: M : Type u_2
ι : Type u_3
R✝ : Type ?u.12927
inst✝² : DecidableEq M
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : CommSemiring R
f : M → ι
m : M
r : R
⊢ Finsupp.single m r ∈ gradeBy R f (f m)

tactic: rw [Finset.mem_singleton.mp (Finsupp.support_single_subset hx)]
state_before: M : Type u_2
ι : Type u_3
R✝ : Type ?u.12927
inst✝² : DecidableEq M
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : CommSemiring R
f : M → ι
m : M
r : R
x : M
hx : x ∈ (Finsupp.single m r).support
⊢ f x = f m
Theorem: has_fderiv_at_filter_real_equiv
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: symm
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ↑f' (x' - x)‖) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ • (f x' - f x - ↑f' (x' - x))) L (𝓝 0)

tactic: rw [tendsto_iff_norm_tendsto_zero]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ • (f x' - f x - ↑f' (x' - x))) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ↑f' (x' - x)‖) L (𝓝 0)

tactic: refine' tendsto_congr fun x' => _
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun e => ‖‖e - x‖⁻¹ • (f e - f x - ↑f' (e - x)) - 0‖) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ↑f' (x' - x)‖) L (𝓝 0)

tactic: simp [norm_smul]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
x' : E
⊢ ‖‖x' - x‖⁻¹ • (f x' - f x - ↑f' (x' - x)) - 0‖ = ‖x' - x‖⁻¹ * ‖f x' - f x - ↑f' (x' - x)‖
Theorem: Subgroup.top_prod
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_snd]
state_before: G : Type u_2
G' : Type ?u.299782
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.299791
inst✝² : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type u_1
inst✝¹ : Group N
P : Type ?u.299818
inst✝ : Group P
H : Subgroup N
x : G × N
⊢ x ∈ prod ⊤ H ↔ x ∈ comap (MonoidHom.snd G N) H
Theorem: List.range_subset
File: Std/Data/List/Lemmas.lean

tactic: simp only [range_eq_range', range'_subset_right]
state_before: m n : Nat
⊢ range m ⊆ range n ↔ m ≤ n
Theorem: IsAlgClosure.equivOfEquiv_symm_algebraMap
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

tactic: simp
state_before: k : Type u
inst✝¹⁴ : Field k
K : Type ?u.954501
J : Type ?u.954504
R : Type u
S : Type u_1
L : Type v
M : Type w
inst✝¹³ : Field K
inst✝¹² : Field J
inst✝¹¹ : CommRing R
inst✝¹⁰ : CommRing S
inst✝⁹ : Field L
inst✝⁸ : Field M
inst✝⁷ : Algebra R M
inst✝⁶ : NoZeroSMulDivisors R M
inst✝⁵ : IsAlgClosure R M
inst✝⁴ : Algebra K M
inst✝³ : IsAlgClosure K M
inst✝² : Algebra S L
inst✝¹ : NoZeroSMulDivisors S L
inst✝ : IsAlgClosure S L
hSR : S ≃+* R
r : R
⊢ ↑(equivOfEquiv L M hSR) (↑(RingEquiv.symm (equivOfEquiv L M hSR)) (↑(algebraMap R M) r)) =
    ↑(equivOfEquiv L M hSR) (↑(algebraMap S L) (↑(RingEquiv.symm hSR) r))
Theorem: Filter.tendsto_congr'
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [Tendsto, Tendsto, map_congr hl]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.309738
ι : Sort x
f₁ f₂ : α → β
l₁ : Filter α
l₂ : Filter β
hl : f₁ =ᶠ[l₁] f₂
⊢ Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂
Theorem: Cardinal.one_le_iff_ne_zero
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [one_le_iff_pos, pos_iff_ne_zero]
state_before: α β : Type u
c : Cardinal
⊢ 1 ≤ c ↔ c ≠ 0
Theorem: LocalEquiv.prod_symm
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: ext x <;> simp [prod_coe_symm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e : LocalEquiv α β
e' : LocalEquiv γ δ
⊢ LocalEquiv.symm (prod e e') = prod (LocalEquiv.symm e) (LocalEquiv.symm e')
Theorem: ENNReal.toNNReal_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← ENNReal.coe_nat n, ENNReal.toNNReal_coe]
state_before: α : Type ?u.103128
β : Type ?u.103131
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ ENNReal.toNNReal ↑n = ↑n
Theorem: Real.IsConjugateExponent.inv_add_inv_conj_nnreal
File: Mathlib/Data/Real/ConjugateExponents.lean

tactic: rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg,
    ← Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
state_before: p q : ℝ
h : IsConjugateExponent p q
⊢ 1 / toNNReal p + 1 / toNNReal q = 1
Theorem: Ideal.IsHomogeneous.mul
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rw [Ideal.IsHomogeneous.iff_exists] at HI HJ⊢
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.185047
A : Type u_1
inst✝⁵ : CommSemiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
HI : IsHomogeneous 𝒜 I
HJ : IsHomogeneous 𝒜 J
⊢ IsHomogeneous 𝒜 (I * J)

tactic: obtain ⟨⟨s₁, rfl⟩, ⟨s₂, rfl⟩⟩ := HI, HJ
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.185047
A : Type u_1
inst✝⁵ : CommSemiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
HI : ∃ S, I = span (Subtype.val '' S)
HJ : ∃ S, J = span (Subtype.val '' S)
⊢ ∃ S, I * J = span (Subtype.val '' S)

tactic: rw [Ideal.span_mul_span']
state_before: case intro.intro
ι : Type u_2
σ : Type u_3
R : Type ?u.185047
A : Type u_1
inst✝⁵ : CommSemiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
s₁ s₂ : Set { x // x ∈ homogeneousSubmonoid 𝒜 }
⊢ ∃ S, span (Subtype.val '' s₁) * span (Subtype.val '' s₂) = span (Subtype.val '' S)

tactic: exact ⟨s₁ * s₂, congr_arg _ <| (Set.image_mul (homogeneousSubmonoid 𝒜).subtype).symm⟩
state_before: case intro.intro
ι : Type u_2
σ : Type u_3
R : Type ?u.185047
A : Type u_1
inst✝⁵ : CommSemiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
s₁ s₂ : Set { x // x ∈ homogeneousSubmonoid 𝒜 }
⊢ ∃ S, span (Subtype.val '' s₁ * Subtype.val '' s₂) = span (Subtype.val '' S)
Theorem: MvPolynomial.coeff_rename_mapDomain
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: apply φ.induction_on' (P := fun ψ => coeff (Finsupp.mapDomain f d) ((rename f) ψ) = coeff d ψ)
state_before: σ : Type u_1
τ : Type u_2
α : Type ?u.911003
R : Type u_3
S : Type ?u.911009
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
φ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff (Finsupp.mapDomain f d) (↑(rename f) φ) = coeff d φ

tactic: intro u r
state_before: case h1
σ : Type u_1
τ : Type u_2
α : Type ?u.911003
R : Type u_3
S : Type ?u.911009
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
φ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ ∀ (u : σ →₀ ℕ) (a : R), coeff (Finsupp.mapDomain f d) (↑(rename f) (↑(monomial u) a)) = coeff d (↑(monomial u) a)

tactic: rw [rename_monomial, coeff_monomial, coeff_monomial]
state_before: case h1
σ : Type u_1
τ : Type u_2
α : Type ?u.911003
R : Type u_3
S : Type ?u.911009
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
φ : MvPolynomial σ R
d u : σ →₀ ℕ
r : R
⊢ coeff (Finsupp.mapDomain f d) (↑(rename f) (↑(monomial u) r)) = coeff d (↑(monomial u) r)

tactic: simp only [(Finsupp.mapDomain_injective hf).eq_iff]
state_before: case h1
σ : Type u_1
τ : Type u_2
α : Type ?u.911003
R : Type u_3
S : Type ?u.911009
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
φ : MvPolynomial σ R
d u : σ →₀ ℕ
r : R
⊢ (if Finsupp.mapDomain f u = Finsupp.mapDomain f d then r else 0) = if u = d then r else 0

tactic: intros
state_before: case h2
σ : Type u_1
τ : Type u_2
α : Type ?u.911003
R : Type u_3
S : Type ?u.911009
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
φ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ ∀ (p q : MvPolynomial σ R),
    coeff (Finsupp.mapDomain f d) (↑(rename f) p) = coeff d p →
      coeff (Finsupp.mapDomain f d) (↑(rename f) q) = coeff d q →
        coeff (Finsupp.mapDomain f d) (↑(rename f) (p + q)) = coeff d (p + q)

tactic: simp only [*, AlgHom.map_add, coeff_add]
state_before: case h2
σ : Type u_1
τ : Type u_2
α : Type ?u.911003
R : Type u_3
S : Type ?u.911009
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
φ : MvPolynomial σ R
d : σ →₀ ℕ
p✝ q✝ : MvPolynomial σ R
a✝¹ : coeff (Finsupp.mapDomain f d) (↑(rename f) p✝) = coeff d p✝
a✝ : coeff (Finsupp.mapDomain f d) (↑(rename f) q✝) = coeff d q✝
⊢ coeff (Finsupp.mapDomain f d) (↑(rename f) (p✝ + q✝)) = coeff d (p✝ + q✝)
Theorem: Finset.equitableOn_iff
File: Mathlib/Data/Set/Equitable.lean

tactic: simp_rw [equitableOn_iff_le_le_add_one, Nat.le_and_le_add_one_iff]
state_before: α : Type u_1
β : Type ?u.11967
s : Finset α
f : α → ℕ
a : α
⊢ EquitableOn (↑s) f ↔ ∀ (a : α), a ∈ s → f a = (∑ i in s, f i) / card s ∨ f a = (∑ i in s, f i) / card s + 1
Theorem: Function.Commute.iterate_pos_eq_iff_map_eq
File: Mathlib/Order/Iterate.lean

tactic: simp only [le_antisymm_iff, h.iterate_pos_le_iff_map_le hf hg hn,
  h.symm.iterate_pos_le_iff_map_le' hg hf hn]
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ (f^[n]) x = (g^[n]) x ↔ f x = g x
Theorem: Subspace.dualPairing_nondegenerate
File: Mathlib/LinearAlgebra/Dual.lean

tactic: constructor
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ LinearMap.Nondegenerate (Submodule.dualPairing W)

tactic: rw [LinearMap.separatingLeft_iff_ker_eq_bot, dualPairing_eq]
state_before: case left
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ LinearMap.SeparatingLeft (Submodule.dualPairing W)

tactic: apply LinearEquiv.ker
state_before: case left
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ LinearMap.ker ↑(quotAnnihilatorEquiv W) = ⊥

tactic: intro x h
state_before: case right
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ LinearMap.SeparatingRight (Submodule.dualPairing W)

tactic: rw [← forall_dual_apply_eq_zero_iff K x]
state_before: case right
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
x : { x // x ∈ W }
h : ∀ (x_1 : Dual K V₁ ⧸ dualAnnihilator W), ↑(↑(Submodule.dualPairing W) x_1) x = 0
⊢ x = 0

tactic: intro φ
state_before: case right
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
x : { x // x ∈ W }
h : ∀ (x_1 : Dual K V₁ ⧸ dualAnnihilator W), ↑(↑(Submodule.dualPairing W) x_1) x = 0
⊢ ∀ (φ : Dual K { x // x ∈ W }), ↑φ x = 0

tactic: simpa only [Submodule.dualPairing_apply, dualLift_of_subtype] using
  h (Submodule.Quotient.mk (W.dualLift φ))
state_before: case right
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
x : { x // x ∈ W }
h : ∀ (x_1 : Dual K V₁ ⧸ dualAnnihilator W), ↑(↑(Submodule.dualPairing W) x_1) x = 0
φ : Dual K { x // x ∈ W }
⊢ ↑φ x = 0
Theorem: Nat.log_div_mul_self
File: Mathlib/Data/Nat/Log.lean

tactic: cases' le_or_lt b 1 with hb hb
state_before: b n : ℕ
⊢ log b (n / b * b) = log b n

tactic: cases' lt_or_le n b with h h
state_before: case inr
b n : ℕ
hb : 1 < b
⊢ log b (n / b * b) = log b n

tactic: rw [log_mul_base hb (Nat.div_pos h (zero_le_one.trans_lt hb)).ne', log_div_base,
  tsub_add_cancel_of_le (succ_le_iff.2 <| log_pos hb h)]
state_before: case inr.inr
b n : ℕ
hb : 1 < b
h : b ≤ n
⊢ log b (n / b * b) = log b n

tactic: rw [log_of_left_le_one hb, log_of_left_le_one hb]
state_before: case inl
b n : ℕ
hb : b ≤ 1
⊢ log b (n / b * b) = log b n

tactic: rw [div_eq_of_lt h, zero_mul, log_zero_right, log_of_lt h]
state_before: case inr.inl
b n : ℕ
hb : 1 < b
h : n < b
⊢ log b (n / b * b) = log b n
Theorem: MeasureTheory.forall_measure_preimage_mul_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: exact ⟨fun h => ⟨h⟩, fun h => h.1⟩
state_before: 𝕜 : Type ?u.128647
G : Type u_1
H : Type ?u.128653
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G), Measure.map (fun x => g * x) μ = μ) ↔ IsMulLeftInvariant μ

tactic: simp_rw [Measure.ext_iff]
state_before: 𝕜 : Type ?u.128647
G : Type u_1
H : Type ?u.128653
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G) (A : Set G), MeasurableSet A → ↑↑μ ((fun h => g * h) ⁻¹' A) = ↑↑μ A) ↔
    ∀ (g : G), Measure.map (fun x => g * x) μ = μ

tactic: refine' forall_congr' fun g => forall_congr' fun A => forall_congr' fun hA => _
state_before: 𝕜 : Type ?u.128647
G : Type u_1
H : Type ?u.128653
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G) (A : Set G), MeasurableSet A → ↑↑μ ((fun h => g * h) ⁻¹' A) = ↑↑μ A) ↔
    ∀ (g : G) (s : Set G), MeasurableSet s → ↑↑(Measure.map (fun x => g * x) μ) s = ↑↑μ s

tactic: rw [map_apply (measurable_const_mul g) hA]
state_before: 𝕜 : Type ?u.128647
G : Type u_1
H : Type ?u.128653
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
g : G
A : Set G
hA : MeasurableSet A
⊢ ↑↑μ ((fun h => g * h) ⁻¹' A) = ↑↑μ A ↔ ↑↑(Measure.map (fun x => g * x) μ) A = ↑↑μ A
Theorem: CategoryTheory.Localization.Construction.NatTransExtension.app_eq
File: Mathlib/CategoryTheory/Localization/Construction.lean

tactic: simp only [app, eqToHom_refl, comp_id, id_comp]
state_before: C : Type u_3
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_2
inst✝ : Category D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
F₁ F₂ : MorphismProperty.Localization W ⥤ D
τ : MorphismProperty.Q W ⋙ F₁ ⟶ MorphismProperty.Q W ⋙ F₂
X : C
⊢ app τ ((MorphismProperty.Q W).obj X) = τ.app X

tactic: rfl
state_before: C : Type u_3
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_2
inst✝ : Category D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
F₁ F₂ : MorphismProperty.Localization W ⥤ D
τ : MorphismProperty.Q W ⋙ F₁ ⟶ MorphismProperty.Q W ⋙ F₂
X : C
⊢ τ.app (Equiv.invFun (objEquiv W) ((MorphismProperty.Q W).obj X)) = τ.app X
Theorem: SimpleGraph.boxProd_adj_right
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: simp only [boxProd_adj, SimpleGraph.irrefl, false_and, and_true, false_or]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9451
G : SimpleGraph α
H : SimpleGraph β
a : α
b₁ b₂ : β
⊢ Adj (G □ H) (a, b₁) (a, b₂) ↔ Adj H b₁ b₂
Theorem: Even.zpow_nonneg
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: obtain ⟨k, rfl⟩ := hn
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d : α
n : ℤ
hn : Even n
a : α
⊢ 0 ≤ a ^ n

tactic: exact zpow_bit0_nonneg _ _
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ (k + k)