1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsKleinFour.nonempty_mulEquiv
File: Mathlib/GroupTheory/SpecificGroups/KleinFour.lean

tactic: classical
let _inst₁ := Fintype.ofFinite G₁
let _inst₁ := Fintype.ofFinite G₂
exact ⟨mulEquiv ((Fintype.equivOfCardEq <| by simp).setValue 1 1) <| by simp⟩
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
⊢ Nonempty (G₁ ≃* G₂)
state_after: no goals

tactic: let _inst₁ := Fintype.ofFinite G₁
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
⊢ Nonempty (G₁ ≃* G₂)
state_after: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
_inst₁ : Fintype G₁ := Fintype.ofFinite G₁
⊢ Nonempty (G₁ ≃* G₂)

tactic: let _inst₁ := Fintype.ofFinite G₂
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
_inst₁ : Fintype G₁ := Fintype.ofFinite G₁
⊢ Nonempty (G₁ ≃* G₂)
state_after: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
_inst₁✝ : Fintype G₁ := Fintype.ofFinite G₁
_inst₁ : Fintype G₂ := Fintype.ofFinite G₂
⊢ Nonempty (G₁ ≃* G₂)

tactic: exact ⟨mulEquiv ((Fintype.equivOfCardEq <| by simp).setValue 1 1) <| by simp⟩
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
_inst₁✝ : Fintype G₁ := Fintype.ofFinite G₁
_inst₁ : Fintype G₂ := Fintype.ofFinite G₂
⊢ Nonempty (G₁ ≃* G₂)
state_after: no goals

tactic: simp
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
_inst₁✝ : Fintype G₁ := Fintype.ofFinite G₁
_inst₁ : Fintype G₂ := Fintype.ofFinite G₂
⊢ Fintype.card G₁ = Fintype.card G₂
state_after: no goals

tactic: simp
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : IsKleinFour G
G₁ : Type u_2
G₂ : Type u_3
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : IsKleinFour G₁
inst✝ : IsKleinFour G₂
_inst₁✝ : Fintype G₁ := Fintype.ofFinite G₁
_inst₁ : Fintype G₂ := Fintype.ofFinite G₂
⊢ ((Fintype.equivOfCardEq ⋯).setValue 1 1) 1 = 1
state_after: no goals
Theorem: wittPolynomial_eq_sum_C_mul_X_pow
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: apply sum_congr rfl
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ wittPolynomial p R n = ∑ i ∈ range (n + 1), C (↑p ^ i) * X i ^ p ^ (n - i)
state_after: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ ∀ x ∈ range (n + 1), (monomial (single x (p ^ (n - x)))) (↑p ^ x) = C (↑p ^ x) * X x ^ p ^ (n - x)

tactic: rintro i -
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ ∀ x ∈ range (n + 1), (monomial (single x (p ^ (n - x)))) (↑p ^ x) = C (↑p ^ x) * X x ^ p ^ (n - x)
state_after: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ (monomial (single i (p ^ (n - i)))) (↑p ^ i) = C (↑p ^ i) * X i ^ p ^ (n - i)

tactic: rw [monomial_eq, Finsupp.prod_single_index]
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ (monomial (single i (p ^ (n - i)))) (↑p ^ i) = C (↑p ^ i) * X i ^ p ^ (n - i)
state_after: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ X i ^ 0 = 1

tactic: rw [pow_zero]
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ X i ^ 0 = 1
state_after: no goals
Theorem: UnivLE.ofEssSurj
File: Mathlib/CategoryTheory/UnivLE.lean

tactic: obtain ⟨a', ⟨m⟩⟩ := w.mem_essImage α
state_before: w : uliftFunctor.{u, v}.EssSurj
α : Type (max u v)
⊢ Small.{v, max u v} α
state_after: case intro.intro
w : uliftFunctor.{u, v}.EssSurj
α : Type (max u v)
a' : Type v
m : uliftFunctor.{u, v}.obj a' ≅ α
⊢ Small.{v, max u v} α

tactic: exact ⟨a', ⟨(Iso.toEquiv m).symm.trans Equiv.ulift⟩⟩
state_before: case intro.intro
w : uliftFunctor.{u, v}.EssSurj
α : Type (max u v)
a' : Type v
m : uliftFunctor.{u, v}.obj a' ≅ α
⊢ Small.{v, max u v} α
state_after: no goals
Theorem: Matrix.mul_adjugate_apply
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: erw [← smul_eq_mul, adjugate, of_apply, ← Pi.smul_apply, ← LinearMap.map_smul, ← Pi.single_smul',
  smul_eq_mul, mul_one]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
i j k : n
⊢ A i k * A.adjugate k j = Aᵀ.cramer (Pi.single k (A i k)) j
state_after: no goals
Theorem: ExceptT.goto_mkLabel
File: Mathlib/Control/Monad/Cont.lean

tactic: cases x
state_before: m : Type u → Type v
inst✝ : Monad m
α β ε : Type u
x : Label (Except ε α) m β
i : α
⊢ goto (mkLabel x) i = mk (Except.ok <$> goto x (Except.ok i))
state_after: case mk
m : Type u → Type v
inst✝ : Monad m
α β ε : Type u
i : α
apply✝ : Except ε α → m β
⊢ goto (mkLabel { apply := apply✝ }) i = mk (Except.ok <$> goto { apply := apply✝ } (Except.ok i))

tactic: rfl
state_before: case mk
m : Type u → Type v
inst✝ : Monad m
α β ε : Type u
i : α
apply✝ : Except ε α → m β
⊢ goto (mkLabel { apply := apply✝ }) i = mk (Except.ok <$> goto { apply := apply✝ } (Except.ok i))
state_after: no goals
Theorem: iSup_extend_bot
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup_split _ fun j => ∃ i, e i = j]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
e : ι → β
he : Injective e
f : ι → α
⊢ ⨆ j, extend e f ⊥ j = ⨆ i, f i
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
e : ι → β
he : Injective e
f : ι → α
⊢ (⨆ i, ⨆ (_ : ∃ i_1, e i_1 = i), extend e f ⊥ i) ⊔ ⨆ i, ⨆ (_ : ¬∃ i_1, e i_1 = i), extend e f ⊥ i = ⨆ i, f i

tactic: simp (config := { contextual := true }) [he.extend_apply, extend_apply', @iSup_comm _ β ι]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
e : ι → β
he : Injective e
f : ι → α
⊢ (⨆ i, ⨆ (_ : ∃ i_1, e i_1 = i), extend e f ⊥ i) ⊔ ⨆ i, ⨆ (_ : ¬∃ i_1, e i_1 = i), extend e f ⊥ i = ⨆ i, f i
state_after: no goals
Theorem: convexJoin_empty_left
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp [convexJoin]
state_before: ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
t : Set E
⊢ convexJoin 𝕜 ∅ t = ∅
state_after: no goals
Theorem: Set.left_mem_uIoc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simp [mem_uIoc]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ a ∈ Ι a b ↔ b < a
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.smul_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [coeFn_smul, Pi.smul_apply]
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0
c : R
μ : FiniteMeasure Ω
s : Set Ω
⊢ (c • μ) s = c • μ s
state_after: no goals
Theorem: Nat.zero_of_testBit_eq_false
File: Mathlib/Data/Nat/Bitwise.lean

tactic: induction' n using Nat.binaryRec with b n hn
state_before: n : ℕ
h : ∀ (i : ℕ), n.testBit i = false
⊢ n = 0
state_after: case z
h : ∀ (i : ℕ), testBit 0 i = false
⊢ 0 = 0

case f
b : Bool
n : ℕ
hn : (∀ (i : ℕ), n.testBit i = false) → n = 0
h : ∀ (i : ℕ), (bit b n).testBit i = false
⊢ bit b n = 0

tactic: rfl
state_before: case z
h : ∀ (i : ℕ), testBit 0 i = false
⊢ 0 = 0
state_after: no goals

tactic: have : b = false := by simpa using h 0
state_before: case f
b : Bool
n : ℕ
hn : (∀ (i : ℕ), n.testBit i = false) → n = 0
h : ∀ (i : ℕ), (bit b n).testBit i = false
⊢ bit b n = 0
state_after: case f
b : Bool
n : ℕ
hn : (∀ (i : ℕ), n.testBit i = false) → n = 0
h : ∀ (i : ℕ), (bit b n).testBit i = false
this : b = false
⊢ bit b n = 0

tactic: rw [this, bit_false, bit0_val, hn fun i => by rw [← h (i + 1), testBit_bit_succ], mul_zero]
state_before: case f
b : Bool
n : ℕ
hn : (∀ (i : ℕ), n.testBit i = false) → n = 0
h : ∀ (i : ℕ), (bit b n).testBit i = false
this : b = false
⊢ bit b n = 0
state_after: no goals

tactic: simpa using h 0
state_before: b : Bool
n : ℕ
hn : (∀ (i : ℕ), n.testBit i = false) → n = 0
h : ∀ (i : ℕ), (bit b n).testBit i = false
⊢ b = false
state_after: no goals

tactic: rw [← h (i + 1), testBit_bit_succ]
state_before: b : Bool
n : ℕ
hn : (∀ (i : ℕ), n.testBit i = false) → n = 0
h : ∀ (i : ℕ), (bit b n).testBit i = false
this : b = false
i : ℕ
⊢ n.testBit i = false
state_after: no goals
Theorem: Filter.principal_bind
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [sSup_image, join_principal_eq_sSup, map_principal, eq_self_iff_true]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
s : Set α
f : α → Filter β
⊢ (map f (𝓟 s)).join = ⨆ x ∈ s, f x
state_after: no goals
Theorem: card_pow_eq_one_eq_orderOf_aux
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: let ⟨i, hi⟩ := b.2
state_before: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → (filter (fun a => a ^ n = 1) univ).card ≤ n
a : α
b : ↥(zpowers a)
⊢ ↑b ^ orderOf a = 1
state_after: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → (filter (fun a => a ^ n = 1) univ).card ≤ n
a : α
b : ↥(zpowers a)
i : ℤ
hi : (fun x => a ^ x) i = ↑b
⊢ ↑b ^ orderOf a = 1

tactic: rw [← hi, ← zpow_natCast, ← zpow_mul, mul_comm, zpow_mul, zpow_natCast,
  pow_orderOf_eq_one, one_zpow]
state_before: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → (filter (fun a => a ^ n = 1) univ).card ≤ n
a : α
b : ↥(zpowers a)
i : ℤ
hi : (fun x => a ^ x) i = ↑b
⊢ ↑b ^ orderOf a = 1
state_after: no goals
Theorem: Subalgebra.fg_top
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: rw [← S.range_val, ← Algebra.map_top]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : ⊤.FG
⊢ S.FG
state_after: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : ⊤.FG
⊢ (map S.val ⊤).FG

tactic: exact FG.map _ h
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : ⊤.FG
⊢ (map S.val ⊤).FG
state_after: no goals

tactic: rw [Algebra.map_top, range_val]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : S.FG
⊢ (map S.val ⊤).FG
state_after: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : S.FG
⊢ S.FG

tactic: exact h
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
h : S.FG
⊢ S.FG
state_after: no goals
Theorem: Set.Finite.eq_of_subset_of_encard_le
File: Mathlib/Data/Set/Card.lean

tactic: rw [← zero_add (a := encard s), ← encard_diff_add_encard_of_subset hst] at hts
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : t.encard ≤ s.encard
⊢ s = t
state_after: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
⊢ s = t

tactic: have hdiff := WithTop.le_of_add_le_add_right (ht.subset hst).encard_lt_top.ne hts
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
⊢ s = t
state_after: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : (t \ s).encard ≤ 0
⊢ s = t

tactic: rw [nonpos_iff_eq_zero, encard_eq_zero, diff_eq_empty] at hdiff
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : (t \ s).encard ≤ 0
⊢ s = t
state_after: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : t ⊆ s
⊢ s = t

tactic: exact hst.antisymm hdiff
state_before: α : Type u_1
β : Type u_2
s t : Set α
ht : t.Finite
hst : s ⊆ t
hts : (t \ s).encard + s.encard ≤ 0 + s.encard
hdiff : t ⊆ s
⊢ s = t
state_after: no goals
Theorem: Filter.cardinalGenerate_isGreatest
File: Mathlib/Order/Filter/CardinalInter.lean

tactic: refine ⟨⟨cardinalInter_ofCardinalGenerate _ _, fun s => CardinalGenerateSets.basic⟩, ?_⟩
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
⊢ IsGreatest {f | CardinalInterFilter f c ∧ g ⊆ f.sets} (cardinalGenerate g hc)
state_after: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
⊢ cardinalGenerate g hc ∈ upperBounds {f | CardinalInterFilter f c ∧ g ⊆ f.sets}

tactic: rintro f ⟨fct, hf⟩
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
⊢ cardinalGenerate g hc ∈ upperBounds {f | CardinalInterFilter f c ∧ g ⊆ f.sets}
state_after: case intro
ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
f : Filter α
fct : CardinalInterFilter f c
hf : g ⊆ f.sets
⊢ f ≤ cardinalGenerate g hc

tactic: rwa [le_cardinalGenerate_iff_of_cardinalInterFilter]
state_before: case intro
ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
f : Filter α
fct : CardinalInterFilter f c
hf : g ⊆ f.sets
⊢ f ≤ cardinalGenerate g hc
state_after: no goals
Theorem: AlgebraicGeometry.isOpenImmersion_stableUnderBaseChange
File: Mathlib/AlgebraicGeometry/Morphisms/OpenImmersion.lean

tactic: intro X Y Z f g H
state_before: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
⊢ ∀ (X Y S : Scheme) (f : X ⟶ S) (g : Y ⟶ S), IsOpenImmersion g → IsOpenImmersion pullback.fst
state_after: X✝ Y✝ Z✝ : Scheme
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion g
⊢ IsOpenImmersion pullback.fst

tactic: infer_instance
state_before: X✝ Y✝ Z✝ : Scheme
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion g
⊢ IsOpenImmersion pullback.fst
state_after: no goals
Theorem: ENNReal.lintegral_mul_le_Lp_mul_Lq_of_ne_zero_of_eq_top
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: refine le_trans le_top (le_of_eq ?_)
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
⊢ ∫⁻ (a : α), (f * g) a ∂μ ≤ (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
⊢ ⊤ = (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)

tactic: have hp0_inv_lt : 0 < 1 / p := by simp [hp0_lt]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
⊢ ⊤ = (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
hp0_inv_lt : 0 < 1 / p
⊢ ⊤ = (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)

tactic: rw [hf_top, ENNReal.top_rpow_of_pos hp0_inv_lt]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
hp0_inv_lt : 0 < 1 / p
⊢ ⊤ = (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
hp0_inv_lt : 0 < 1 / p
⊢ ⊤ = ⊤ * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)

tactic: simp [hq0, hg_nonzero]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
hp0_inv_lt : 0 < 1 / p
⊢ ⊤ = ⊤ * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q)
state_after: no goals

tactic: simp [hp0_lt]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hp0_lt : 0 < p
hq0 : 0 ≤ q
f g : α → ℝ≥0∞
hf_top : ∫⁻ (a : α), f a ^ p ∂μ = ⊤
hg_nonzero : ∫⁻ (a : α), g a ^ q ∂μ ≠ 0
⊢ 0 < 1 / p
state_after: no goals
Theorem: PartENat.card_sum
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: simp only [PartENat.card, Cardinal.mk_sum, map_add, Cardinal.toPartENat_lift]
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u_3
β : Type u_4
⊢ card (α ⊕ β) = card α + card β
state_after: no goals
Theorem: Set.Iic_diff_Iic
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [diff_eq, compl_Iic, inter_comm, Ioi_inter_Iic]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Iic b \ Iic a = Ioc a b
state_after: no goals
Theorem: Complex.dist_conj_self
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [dist_of_re_eq (conj_re z), conj_im, dist_comm, Real.dist_eq, sub_neg_eq_add, ← two_mul,
  _root_.abs_mul, abs_of_pos (zero_lt_two' ℝ)]
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℂ
⊢ dist ((starRingEnd ℂ) z) z = 2 * |z.im|
state_after: no goals
Theorem: LaurentPolynomial.support_C_mul_T_of_ne_zero
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: rw [← single_eq_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
n : ℤ
⊢ (C a * T n).support = {n}
state_after: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
n : ℤ
⊢ (Finsupp.single n a).support = {n}

tactic: exact support_single_ne_zero _ a0
state_before: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
n : ℤ
⊢ (Finsupp.single n a).support = {n}
state_after: no goals
Theorem: Equiv.Perm.cycleOf_eq_one_iff
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: simp_rw [ext_iff, cycleOf_apply, one_apply]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
⊢ f.cycleOf x = 1 ↔ f x = x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
⊢ (∀ (x_1 : α), (if f.SameCycle x x_1 then f x_1 else x_1) = x_1) ↔ f x = x

tactic: refine ⟨fun h => (if_pos (SameCycle.refl f x)).symm.trans (h x), fun h y => ?_⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
⊢ (∀ (x_1 : α), (if f.SameCycle x x_1 then f x_1 else x_1) = x_1) ↔ f x = x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
⊢ (if f.SameCycle x y then f y else y) = y

tactic: by_cases hy : f y = y
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
⊢ (if f.SameCycle x y then f y else y) = y
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
hy : f y = y
⊢ (if f.SameCycle x y then f y else y) = y

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
hy : ¬f y = y
⊢ (if f.SameCycle x y then f y else y) = y

tactic: rw [hy, ite_self]
state_before: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
hy : f y = y
⊢ (if f.SameCycle x y then f y else y) = y
state_after: no goals

tactic: exact if_neg (mt SameCycle.apply_eq_self_iff (by tauto))
state_before: case neg
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
hy : ¬f y = y
⊢ (if f.SameCycle x y then f y else y) = y
state_after: no goals

tactic: tauto
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
h : f x = x
y : α
hy : ¬f y = y
⊢ ¬(f x = x ↔ f y = y)
state_after: no goals
Theorem: AlgebraicGeometry.StructureSheaf.const_mul_cancel
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [const_mul, const_ext]
state_before: R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ const R f g₁ U hu₁ * const R g₁ g₂ U hu₂ = const R f g₂ U hu₂
state_after: case h
R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ f * g₁ * g₂ = f * (g₁ * g₂)

tactic: rw [mul_assoc]
state_before: case h
R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ f * g₁ * g₂ = f * (g₁ * g₂)
state_after: no goals
Theorem: max_eq_left
File: Mathlib/Init/Order/LinearOrder.lean

tactic: apply Eq.symm
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
⊢ max a b = a
state_after: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
⊢ a = max a b

tactic: apply eq_max (le_refl _) h
state_before: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
⊢ a = max a b
state_after: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
⊢ ∀ {d : α}, a ≤ d → b ≤ d → a ≤ d

tactic: intros
state_before: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
⊢ ∀ {d : α}, a ≤ d → b ≤ d → a ≤ d
state_after: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
d✝ : α
a✝¹ : a ≤ d✝
a✝ : b ≤ d✝
⊢ a ≤ d✝

tactic: assumption
state_before: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : b ≤ a
d✝ : α
a✝¹ : a ≤ d✝
a✝ : b ≤ d✝
⊢ a ≤ d✝
state_after: no goals