tasksource/leandojo huggingface dataset:
Theorem: Doset.left_bot_eq_left_quot
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: unfold Quotient
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.69926
inst✝ : Mul α
J : Subgroup G
g : G
H : Subgroup G
⊢ Quotient ↑⊥.toSubmonoid ↑H = (G ⧸ H)

tactic: congr
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.69926
inst✝ : Mul α
J : Subgroup G
g : G
H : Subgroup G
⊢ _root_.Quotient (setoid ↑⊥.toSubmonoid ↑H) = (G ⧸ H)

tactic: ext
state_before: case e_s
G : Type u_1
inst✝¹ : Group G
α : Type ?u.69926
inst✝ : Mul α
J : Subgroup G
g : G
H : Subgroup G
⊢ setoid ↑⊥.toSubmonoid ↑H = QuotientGroup.leftRel H

tactic: simp_rw [← bot_rel_eq_leftRel H]
state_before: case e_s.H
G : Type u_1
inst✝¹ : Group G
α : Type ?u.69926
inst✝ : Mul α
J : Subgroup G
g : G
H : Subgroup G
a✝ b✝ : G
⊢ Setoid.Rel (setoid ↑⊥.toSubmonoid ↑H) a✝ b✝ ↔ Setoid.Rel (QuotientGroup.leftRel H) a✝ b✝

tactic: rfl
state_before: case e_s.H
G : Type u_1
inst✝¹ : Group G
α : Type ?u.69926
inst✝ : Mul α
J : Subgroup G
g : G
H : Subgroup G
a✝ b✝ : G
⊢ Setoid.Rel (setoid ↑⊥.toSubmonoid ↑H) a✝ b✝ ↔ Setoid.Rel (setoid ↑⊥ ↑H) a✝ b✝
Theorem: pow_gcd_eq_one
File: Mathlib/Data/Int/GCD.lean

tactic: rcases m with (rfl | m)
state_before: M : Type u_1
inst✝ : Monoid M
x : M
m n : ℕ
hm : x ^ m = 1
hn : x ^ n = 1
⊢ x ^ Nat.gcd m n = 1

tactic: obtain ⟨y, rfl⟩ := isUnit_ofPowEqOne hm m.succ_ne_zero
state_before: case succ
M : Type u_1
inst✝ : Monoid M
x : M
n : ℕ
hn : x ^ n = 1
m : ℕ
hm : x ^ Nat.succ m = 1
⊢ x ^ Nat.gcd (Nat.succ m) n = 1

tactic: simp only [← Units.val_pow_eq_pow_val] at *
state_before: case succ.intro
M : Type u_1
inst✝ : Monoid M
n m : ℕ
y : Mˣ
hn : ↑y ^ n = 1
hm : ↑y ^ Nat.succ m = 1
⊢ ↑y ^ Nat.gcd (Nat.succ m) n = 1

tactic: rw [← Units.val_one, ← zpow_coe_nat, ← Units.ext_iff] at *
state_before: case succ.intro
M : Type u_1
inst✝ : Monoid M
n m : ℕ
y : Mˣ
hn : ↑(y ^ n) = 1
hm : ↑(y ^ Nat.succ m) = 1
⊢ ↑(y ^ Nat.gcd (Nat.succ m) n) = 1

tactic: simp only [Nat.gcd_eq_gcd_ab, zpow_add, zpow_mul, hm, hn, one_zpow, one_mul]
state_before: case succ.intro
M : Type u_1
inst✝ : Monoid M
n m : ℕ
y : Mˣ
hn : y ^ ↑n = 1
hm : y ^ ↑(Nat.succ m) = 1
⊢ y ^ ↑(Nat.gcd (Nat.succ m) n) = 1

tactic: simp [hn]
state_before: case zero
M : Type u_1
inst✝ : Monoid M
x : M
n : ℕ
hn : x ^ n = 1
hm : x ^ Nat.zero = 1
⊢ x ^ Nat.gcd Nat.zero n = 1
Theorem: Fin.coe_of_injective_castSucc_symm
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← coe_castSucc]
state_before: n✝ m n : ℕ
i : Fin (Nat.succ n)
hi : i ∈ Set.range ↑castSucc
⊢ ↑(↑(Equiv.ofInjective ↑castSucc (_ : Injective ↑castSucc)).symm { val := i, property := hi }) = ↑i

tactic: exact congr_arg val (Equiv.apply_ofInjective_symm _ _)
state_before: n✝ m n : ℕ
i : Fin (Nat.succ n)
hi : i ∈ Set.range ↑castSucc
⊢ ↑(↑castSucc (↑(Equiv.ofInjective ↑castSucc (_ : Injective ↑castSucc)).symm { val := i, property := hi })) = ↑i
Theorem: Multiset.coe_sigma
File: Mathlib/Data/Multiset/Bind.lean

tactic: rw [Multiset.sigma, List.sigma, ← coe_bind]
state_before: α : Type u_1
β : Type ?u.67678
γ : Type ?u.67681
δ : Type ?u.67684
σ : α → Type u_2
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
l₁ : List α
l₂ : (a : α) → List (σ a)
⊢ (Multiset.sigma ↑l₁ fun a => ↑(l₂ a)) = ↑(List.sigma l₁ l₂)

tactic: simp
state_before: α : Type u_1
β : Type ?u.67678
γ : Type ?u.67681
δ : Type ?u.67684
σ : α → Type u_2
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
l₁ : List α
l₂ : (a : α) → List (σ a)
⊢ (bind ↑l₁ fun a => map (Sigma.mk a) ↑(l₂ a)) = bind ↑l₁ fun a => ↑(List.map (Sigma.mk a) (l₂ a))
Theorem: MeasureTheory.L1.integral_zero
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.429938
𝕜 : Type ?u.429941
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ integral 0 = 0

tactic: exact map_zero integralCLM
state_before: α : Type u_2
E : Type u_1
F : Type ?u.429938
𝕜 : Type ?u.429941
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ ↑integralCLM 0 = 0
Theorem: mem_map_indicator_ae_iff_of_zero_nmem
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [mem_map, mem_ae_iff, Set.indicator_preimage, Set.ite, Set.compl_union, Set.compl_inter]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.4552540
δ : Type ?u.4552543
ι : Type ?u.4552546
R : Type ?u.4552549
R' : Type ?u.4552552
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
t : Set β
ht : ¬0 ∈ t
⊢ t ∈ Filter.map (indicator s f) (ae μ) ↔ ↑↑μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0

tactic: change μ (((f ⁻¹' t)ᶜ ∪ sᶜ) ∩ ((fun _ => (0 : β)) ⁻¹' t \ s)ᶜ) = 0 ↔ μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.4552540
δ : Type ?u.4552543
ι : Type ?u.4552546
R : Type ?u.4552549
R' : Type ?u.4552552
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
t : Set β
ht : ¬0 ∈ t
⊢ ↑↑μ (((f ⁻¹' t)ᶜ ∪ sᶜ) ∩ (0 ⁻¹' t \ s)ᶜ) = 0 ↔ ↑↑μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0

tactic: simp only [ht, if_false, Set.compl_empty, Set.empty_diff, Set.inter_univ, Set.preimage_const]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.4552540
δ : Type ?u.4552543
ι : Type ?u.4552546
R : Type ?u.4552549
R' : Type ?u.4552552
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
t : Set β
ht : ¬0 ∈ t
⊢ ↑↑μ (((f ⁻¹' t)ᶜ ∪ sᶜ) ∩ ((fun x => 0) ⁻¹' t \ s)ᶜ) = 0 ↔ ↑↑μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0
Theorem: reesAlgebra.fg
File: Mathlib/RingTheory/ReesAlgebra.lean

tactic: classical
  obtain ⟨s, hs⟩ := hI
  rw [← adjoin_monomial_eq_reesAlgebra, ← hs]
  use s.image (monomial 1)
  rw [Finset.coe_image]
  change
    _ =
      Algebra.adjoin R
        (Submodule.map (monomial 1 : R →ₗ[R] R[X]) (Submodule.span R ↑s) : Set R[X])
  rw [Submodule.map_span, Algebra.adjoin_span]
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
hI : Ideal.FG I
⊢ Subalgebra.FG (reesAlgebra I)

tactic: obtain ⟨s, hs⟩ := hI
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
hI : Ideal.FG I
⊢ Subalgebra.FG (reesAlgebra I)

tactic: rw [← adjoin_monomial_eq_reesAlgebra, ← hs]
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
s : Finset R
hs : Ideal.span ↑s = I
⊢ Subalgebra.FG (reesAlgebra I)

tactic: use s.image (monomial 1)
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
s : Finset R
hs : Ideal.span ↑s = I
⊢ Subalgebra.FG (Algebra.adjoin R ↑(Submodule.map (monomial 1) (Ideal.span ↑s)))

tactic: rw [Finset.coe_image]
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
s : Finset R
hs : Ideal.span ↑s = I
⊢ Algebra.adjoin R ↑(Finset.image (↑(monomial 1)) s) = Algebra.adjoin R ↑(Submodule.map (monomial 1) (Ideal.span ↑s))

tactic: change
  _ =
    Algebra.adjoin R
      (Submodule.map (monomial 1 : R →ₗ[R] R[X]) (Submodule.span R ↑s) : Set R[X])
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
s : Finset R
hs : Ideal.span ↑s = I
⊢ Algebra.adjoin R (↑(monomial 1) '' ↑s) = Algebra.adjoin R ↑(Submodule.map (monomial 1) (Ideal.span ↑s))

tactic: rw [Submodule.map_span, Algebra.adjoin_span]
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
s : Finset R
hs : Ideal.span ↑s = I
⊢ Algebra.adjoin R (↑(monomial 1) '' ↑s) = Algebra.adjoin R ↑(Submodule.map (monomial 1) (Submodule.span R ↑s))
Theorem: spectrum.singleton_sub_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: rw [sub_eq_add_neg, neg_eq, singleton_add_eq, sub_eq_add_neg]
state_before: R : Type u
A : Type v
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
r : R
⊢ {r} - σ a = σ (↑↑ₐ r - a)
Theorem: ContinuousOn.preimage_interior_subset_interior_preimage
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [interior_inter, hs.interior_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.346669
δ : Type ?u.346672
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsOpen s
⊢ interior (s ∩ f ⁻¹' t) = s ∩ interior (f ⁻¹' t)
Theorem: Multiset.prod_eq_prod_toEnumFinset
File: Mathlib/Data/Multiset/Fintype.lean

tactic: congr
state_before: α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
inst✝ : CommMonoid α
m : Multiset α
⊢ prod m = ∏ x in toEnumFinset m, x.fst

tactic: simp
state_before: case e_a
α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
inst✝ : CommMonoid α
m : Multiset α
⊢ m = map (fun x => x.fst) (toEnumFinset m).val
Theorem: MeasureTheory.L1.SimpleFunc.norm_integral_le_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [integral, norm_eq_integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.291771
𝕜 : Type ?u.291774
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace ℝ E
inst✝² : SMulCommClass ℝ 𝕜 E
F' : Type ?u.294149
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
f : { x // x ∈ simpleFunc E 1 μ }
⊢ ‖integral f‖ ≤ ‖f‖

tactic: exact (toSimpleFunc f).norm_integral_le_integral_norm (SimpleFunc.integrable f)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.291771
𝕜 : Type ?u.291774
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace ℝ E
inst✝² : SMulCommClass ℝ 𝕜 E
F' : Type ?u.294149
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
f : { x // x ∈ simpleFunc E 1 μ }
⊢ ‖MeasureTheory.SimpleFunc.integral μ (toSimpleFunc f)‖ ≤
    MeasureTheory.SimpleFunc.integral μ (SimpleFunc.map norm (toSimpleFunc f))
Theorem: Complex.cpow_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp only [cpow_def]
state_before: x y : ℂ
⊢ x ^ y = 0 ↔ x = 0 ∧ y ≠ 0

tactic: split_ifs <;> simp [*, exp_ne_zero]
state_before: x y : ℂ
⊢ (if x = 0 then if y = 0 then 1 else 0 else exp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0
Theorem: BoundedContinuousFunction.range_toLpHom
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: symm
state_before: α : Type u_1
E : Type u_2
F : Type ?u.10310262
G : Type ?u.10310265
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
⊢ NormedAddGroupHom.range (toLpHom p μ) = Lp.boundedContinuousFunction E p μ

tactic: convert AddMonoidHom.addSubgroupOf_range_eq_of_le
    ((ContinuousMap.toAEEqFunAddHom μ).comp (toContinuousMapAddHom α E))
    (by rintro - ⟨f, rfl⟩; exact mem_Lp f : _ ≤ Lp E p μ)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.10310262
G : Type ?u.10310265
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
⊢ Lp.boundedContinuousFunction E p μ = NormedAddGroupHom.range (toLpHom p μ)

tactic: rintro - ⟨f, rfl⟩
state_before: α : Type u_1
E : Type u_2
F : Type ?u.10310262
G : Type ?u.10310265
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
⊢ AddMonoidHom.range (AddMonoidHom.comp (ContinuousMap.toAEEqFunAddHom μ) (toContinuousMapAddHom α E)) ≤ Lp E p

tactic: exact mem_Lp f
state_before: case intro
α : Type u_1
E : Type u_2
F : Type ?u.10310262
G : Type ?u.10310265
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : TopologicalSpace α
inst✝³ : BorelSpace α
inst✝² : SecondCountableTopologyEither α E
inst✝¹ : IsFiniteMeasure μ
inst✝ : Fact (1 ≤ p)
f : α →ᵇ E
⊢ ↑(AddMonoidHom.comp (ContinuousMap.toAEEqFunAddHom μ) (toContinuousMapAddHom α E)) f ∈ Lp E p
Theorem: MeasureTheory.Measure.univ_pi_Ico_ae_eq_Icc
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [← pi_univ_Icc]
state_before: ι : Type u_2
ι' : Type ?u.4891185
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (Set.pi univ fun i => Ico (f i) (g i)) =ᶠ[ae (Measure.pi μ)] Icc f g

tactic: exact pi_Ico_ae_eq_pi_Icc
state_before: ι : Type u_2
ι' : Type ?u.4891185
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f g : (i : ι) → α i
⊢ (Set.pi univ fun i => Ico (f i) (g i)) =ᶠ[ae (Measure.pi μ)] Set.pi univ fun i => Icc (f i) (g i)
Theorem: Set.insert_diff_eq_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : ¬a ∈ s
⊢ insert a s \ s = {a}

tactic: rw [Set.mem_diff, Set.mem_insert_iff, Set.mem_singleton_iff, or_and_right, and_not_self_iff,
  or_false_iff, and_iff_left_iff_imp]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : ¬a ∈ s
x✝ : α
⊢ x✝ ∈ insert a s \ s ↔ x✝ ∈ {a}

tactic: rintro rfl
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : ¬a ∈ s
x✝ : α
⊢ x✝ = a → ¬x✝ ∈ s

tactic: exact h
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x✝ : α
h : ¬x✝ ∈ s
⊢ ¬x✝ ∈ s
Theorem: NNRat.ext_num_den_iff
File: Mathlib/Data/Rat/NNRat.lean

tactic: rintro rfl
state_before: p q : ℚ≥0
⊢ p = q → num p = num q ∧ den p = den q

tactic: exact ⟨rfl, rfl⟩
state_before: p : ℚ≥0
⊢ num p = num p ∧ den p = den p
Theorem: Nat.max_sq_add_min_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: rw [pair]
state_before: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ pair m n

tactic: cases' lt_or_le m n with h h
state_before: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

tactic: rw [if_pos h, max_eq_right h.le, min_eq_left h.le, sq]
state_before: case inl
m n : ℕ
h : m < n
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

case inr
m n : ℕ
h : n ≤ m
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

tactic: rw [if_neg h.not_lt, max_eq_left h, min_eq_right h, sq, add_assoc, add_le_add_iff_left]
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

tactic: exact le_add_self
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ n ≤ m + n
Theorem: Finset.max'_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp only [max', Finset.max, id_eq, coe_sup']
state_before: F : Type ?u.336690
α : Type u_1
β : Type ?u.336696
γ : Type ?u.336699
ι : Type ?u.336702
κ : Type ?u.336705
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
⊢ Finset.max s = ↑(max' s H)

tactic: rfl
state_before: F : Type ?u.336690
α : Type u_1
β : Type ?u.336696
γ : Type ?u.336699
ι : Type ?u.336702
κ : Type ?u.336705
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
⊢ sup s WithBot.some = sup s (WithBot.some ∘ fun x => x)
Theorem: MeasureTheory.snorm_const'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm_eq_snorm' h0 h_top, snorm'_const, ENNReal.toReal_pos h0 h_top]
state_before: α : Type u_1
E : Type ?u.1186891
F : Type u_2
G : Type ?u.1186897
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
h_top : p ≠ ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * ↑↑μ Set.univ ^ (1 / ENNReal.toReal p)
Theorem: norm_inv'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa using norm_div_rev 1 a
state_before: 𝓕 : Type ?u.54204
𝕜 : Type ?u.54207
α : Type ?u.54210
ι : Type ?u.54213
κ : Type ?u.54216
E : Type u_1
F : Type ?u.54222
G : Type ?u.54225
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ ‖a⁻¹‖ = ‖a‖
Theorem: integral_sin_pow_mul_cos_pow_odd
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [_root_.pow_zero, _root_.pow_succ', mul_assoc, pow_mul, one_mul]
state_before: a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
⊢ (∫ (x : ℝ) in a..b, sin x ^ m * cos x ^ (2 * n + 1)) = ∫ (x : ℝ) in a..b, sin x ^ m * (1 - sin x ^ 2) ^ n * cos x

tactic: congr! 5
state_before: a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
⊢ (∫ (x : ℝ) in a..b, sin x ^ m * ((cos x * cos x) ^ n * cos x)) =
    ∫ (x : ℝ) in a..b, sin x ^ m * ((1 - sin x * sin x) ^ n * cos x)

tactic: rw [← sq, ← sq, cos_sq']
state_before: case h.e'_5.h.h.e'_6.h.e'_5.h.e'_5
a b : ℝ
n✝ m n : ℕ
hc : Continuous fun u => u ^ m * (1 - u ^ 2) ^ n
x✝ : ℝ
⊢ cos x✝ * cos x✝ = 1 - sin x✝ * sin x✝
Theorem: sbtw_one_zero_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [sbtw_comm, sbtw_zero_one_iff]
state_before: R : Type u_1
V : Type ?u.269565
V' : Type ?u.269568
P : Type ?u.269571
P' : Type ?u.269574
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ Sbtw R 1 x 0 ↔ x ∈ Set.Ioo 0 1
Theorem: AlgebraicTopology.DoldKan.hσ'_eq'
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

tactic: rw [hσ'_eq ha rfl, eqToHom_refl, comp_id]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a : ℕ
ha : n = a + q
⊢ hσ' q n (n + 1) (_ : n + 1 = n + 1) = (-1) ^ a • σ X { val := a, isLt := (_ : a < Nat.succ n) }
Theorem: Units.mul_inv_cancel_left
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← mul_assoc, mul_inv, one_mul]
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c u a : αˣ
b : α
⊢ ↑a * (↑a⁻¹ * b) = b
Theorem: MeasureTheory.Lp.edist_toLp_zero
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: convert edist_toLp_toLp f 0 hf zero_memℒp
state_before: α : Type u_2
E : Type u_1
F : Type ?u.390075
G : Type ?u.390078
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p
⊢ edist (Memℒp.toLp f hf) 0 = snorm f p μ

tactic: simp
state_before: case h.e'_3.h.e'_5
α : Type u_2
E : Type u_1
F : Type ?u.390075
G : Type ?u.390078
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p
⊢ f = f - 0
Theorem: Ordinal.nadd_comm
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def, nadd_def, max_comm]
state_before: a✝ b✝ c : Ordinal
a b : Ordinal
⊢ a ♯ b = b ♯ a

tactic: congr <;> ext <;> apply nadd_comm
state_before: a✝ b✝ c : Ordinal
a b : Ordinal
⊢ max (blsub b fun b' x => a ♯ b') (blsub a fun a' x => a' ♯ b) =
    max (blsub b fun a' x => a' ♯ a) (blsub a fun b' x => b ♯ b')
Theorem: continuousAt_clog
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: refine' ContinuousAt.add _ _
state_before: α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ ContinuousAt log x

tactic: refine' continuous_ofReal.continuousAt.comp _
state_before: case refine'_1
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ ContinuousAt (fun x => ↑(Real.log (↑Complex.abs x))) x

tactic: refine' (Real.continuousAt_log _).comp Complex.continuous_abs.continuousAt
state_before: case refine'_1
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ ContinuousAt (fun x => Real.log (↑Complex.abs x)) x

tactic: rw [Complex.abs.ne_zero_iff]
state_before: case refine'_1
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ ↑Complex.abs x ≠ 0

tactic: rintro rfl
state_before: case refine'_1
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ x ≠ 0

tactic: simp at h
state_before: case refine'_1
α : Type ?u.271373
h : 0 < 0.re ∨ 0.im ≠ 0
⊢ False

tactic: have h_cont_mul : Continuous fun x : ℂ => x * I := continuous_id'.mul continuous_const
state_before: case refine'_2
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ ContinuousAt (fun x => ↑(arg x) * I) x

tactic: refine' h_cont_mul.continuousAt.comp (continuous_ofReal.continuousAt.comp _)
state_before: case refine'_2
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
h_cont_mul : Continuous fun x => x * I
⊢ ContinuousAt (fun x => ↑(arg x) * I) x

tactic: exact continuousAt_arg h
state_before: case refine'_2
α : Type ?u.271373
x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
h_cont_mul : Continuous fun x => x * I
⊢ ContinuousAt (fun x => arg x) x
Theorem: Function.IsPeriodicPt.eq_of_apply_eq_same
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [← hx.eq, ← hy.eq, ← iterate_pred_comp_of_pos f hn, comp_apply, comp_apply, h]
state_before: α : Type u_1
β : Type ?u.4108
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : IsPeriodicPt f n x
hy : IsPeriodicPt f n y
hn : 0 < n
h : f x = f y
⊢ x = y
Theorem: Real.cosh_abs
File: Mathlib/Data/Complex/Exponential.lean

tactic: cases le_total x 0 <;> simp [*, _root_.abs_of_nonneg, abs_of_nonpos]
state_before: x y : ℝ
⊢ cosh (abs' x) = cosh x
Theorem: isLittleO_pow_exp_pos_mul_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simpa using isLittleO_zpow_exp_pos_mul_atTop k hb
state_before: k : ℕ
b : ℝ
hb : 0 < b
⊢ (fun x => x ^ ↑k) =o[atTop] fun x => exp (b * x)