1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.RightHomologyData.opcyclesIso_inv_comp_descOpcycles
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: simp only [← cancel_epi h.p, p_comp_opcyclesIso_inv_assoc, p_descOpcycles, p_descQ]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝ : S.HasRightHomology
⊢ h.opcyclesIso.inv ≫ S.descOpcycles k hk = h.descQ k hk
state_after: no goals
Theorem: Set.preimage_neg_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp only [← Icc_min_max, preimage_neg_Icc, min_neg_neg, max_neg_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ -[[a, b]] = [[-a, -b]]
state_after: no goals
Theorem: Monoid.PushoutI.NormalWord.transversal_nonempty
File: Mathlib/GroupTheory/PushoutI.lean

tactic: choose t ht using fun i => (φ i).range.exists_right_transversal 1
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Group (G i)
inst✝ : Group H
φ : (i : ι) → H →* G i
hφ : ∀ (i : ι), Injective ⇑(φ i)
⊢ Nonempty (Transversal φ)
state_after: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Group (G i)
inst✝ : Group H
φ : (i : ι) → H →* G i
hφ : ∀ (i : ι), Injective ⇑(φ i)
t : (i : ι) → Set (G i)
ht : ∀ (i : ι), t i ∈ rightTransversals ↑(φ i).range ∧ 1 ∈ t i
⊢ Nonempty (Transversal φ)

tactic: apply Nonempty.intro
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Group (G i)
inst✝ : Group H
φ : (i : ι) → H →* G i
hφ : ∀ (i : ι), Injective ⇑(φ i)
t : (i : ι) → Set (G i)
ht : ∀ (i : ι), t i ∈ rightTransversals ↑(φ i).range ∧ 1 ∈ t i
⊢ Nonempty (Transversal φ)
state_after: case val
ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Group (G i)
inst✝ : Group H
φ : (i : ι) → H →* G i
hφ : ∀ (i : ι), Injective ⇑(φ i)
t : (i : ι) → Set (G i)
ht : ∀ (i : ι), t i ∈ rightTransversals ↑(φ i).range ∧ 1 ∈ t i
⊢ Transversal φ

tactic: exact
  { injective := hφ
    set := t
    one_mem := fun i => (ht i).2
    compl := fun i => (ht i).1 }
state_before: case val
ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Group (G i)
inst✝ : Group H
φ : (i : ι) → H →* G i
hφ : ∀ (i : ι), Injective ⇑(φ i)
t : (i : ι) → Set (G i)
ht : ∀ (i : ι), t i ∈ rightTransversals ↑(φ i).range ∧ 1 ∈ t i
⊢ Transversal φ
state_after: no goals
Theorem: LinearMap.mapsTo_biSup_of_mapsTo
File: Mathlib/Algebra/DirectSum/LinearMap.lean

tactic: replace hf : ∀ i, (N i).map f ≤ N i := fun i ↦ Submodule.map_le_iff_le_comap.mpr (hf i)
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : ι → Submodule R M
inst✝² : DecidableEq ι
h : IsInternal N
inst✝¹ : ∀ (i : ι), Module.Finite R ↥(N i)
inst✝ : ∀ (i : ι), Module.Free R ↥(N i)
s : Set ι
f : Module.End R M
hf : ∀ (i : ι), MapsTo ⇑f ↑(N i) ↑(N i)
⊢ MapsTo ⇑f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : ι → Submodule R M
inst✝² : DecidableEq ι
h : IsInternal N
inst✝¹ : ∀ (i : ι), Module.Finite R ↥(N i)
inst✝ : ∀ (i : ι), Module.Free R ↥(N i)
s : Set ι
f : Module.End R M
hf : ∀ (i : ι), Submodule.map f (N i) ≤ N i
⊢ MapsTo ⇑f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)

tactic: suffices (⨆ i ∈ s, N i).map f ≤ ⨆ i ∈ s, N i from Submodule.map_le_iff_le_comap.mp this
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : ι → Submodule R M
inst✝² : DecidableEq ι
h : IsInternal N
inst✝¹ : ∀ (i : ι), Module.Finite R ↥(N i)
inst✝ : ∀ (i : ι), Module.Free R ↥(N i)
s : Set ι
f : Module.End R M
hf : ∀ (i : ι), Submodule.map f (N i) ≤ N i
⊢ MapsTo ⇑f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : ι → Submodule R M
inst✝² : DecidableEq ι
h : IsInternal N
inst✝¹ : ∀ (i : ι), Module.Finite R ↥(N i)
inst✝ : ∀ (i : ι), Module.Free R ↥(N i)
s : Set ι
f : Module.End R M
hf : ∀ (i : ι), Submodule.map f (N i) ≤ N i
⊢ Submodule.map f (⨆ i ∈ s, N i) ≤ ⨆ i ∈ s, N i

tactic: simpa only [Submodule.map_iSup] using iSup₂_mono <| fun i _ ↦ hf i
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : ι → Submodule R M
inst✝² : DecidableEq ι
h : IsInternal N
inst✝¹ : ∀ (i : ι), Module.Finite R ↥(N i)
inst✝ : ∀ (i : ι), Module.Free R ↥(N i)
s : Set ι
f : Module.End R M
hf : ∀ (i : ι), Submodule.map f (N i) ≤ N i
⊢ Submodule.map f (⨆ i ∈ s, N i) ≤ ⨆ i ∈ s, N i
state_after: no goals
Theorem: Localization.AtPrime.nilpotent_iff_mem_maximal_of_minimal
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: rw [nilpotent_iff_mem_prime]
state_before: R : Type u_1
inst✝ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimalPrimes R
x : Localization I.primeCompl
⊢ IsNilpotent x ↔ x ∈ LocalRing.maximalIdeal (Localization I.primeCompl)
state_after: R : Type u_1
inst✝ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimalPrimes R
x : Localization I.primeCompl
⊢ (∀ (J : Ideal (Localization I.primeCompl)), J.IsPrime → x ∈ J) ↔
    x ∈ LocalRing.maximalIdeal (Localization I.primeCompl)

tactic: simpa [prime_unique_of_minimal hMin J]
state_before: R : Type u_1
inst✝ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimalPrimes R
x : Localization I.primeCompl
x✝¹ : x ∈ LocalRing.maximalIdeal (Localization I.primeCompl)
J : Ideal (Localization I.primeCompl)
x✝ : J.IsPrime
⊢ x ∈ J
state_after: no goals
Theorem: Subgroup.IsComplement.mul_eq
File: Mathlib/GroupTheory/Complement.lean

tactic: simpa [mem_mul] using (h.existsUnique x).exists
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S T
x : G
⊢ x ∈ S * T
state_after: no goals
Theorem: Matrix.PosSemidef.add
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: rw [add_mulVec, dotProduct_add]
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosSemidef
x : m → R
⊢ 0 ≤ star x ⬝ᵥ (A + B) *ᵥ x
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosSemidef
x : m → R
⊢ 0 ≤ star x ⬝ᵥ A *ᵥ x + star x ⬝ᵥ B *ᵥ x

tactic: exact add_nonneg (hA.2 x) (hB.2 x)
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosSemidef
x : m → R
⊢ 0 ≤ star x ⬝ᵥ A *ᵥ x + star x ⬝ᵥ B *ᵥ x
state_after: no goals
Theorem: MeasureTheory.lintegral_congr
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
h : ∀ (a : α), f a = g a
⊢ ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), g a ∂μ
state_after: no goals
Theorem: ContDiffAt.const_smul
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: rw [← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
f : E → F
x : E
c : R
hf : ContDiffAt 𝕜 n f x
⊢ ContDiffAt 𝕜 n (fun y => c • f y) x
state_after: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
f : E → F
x : E
c : R
hf : ContDiffWithinAt 𝕜 n f univ x
⊢ ContDiffWithinAt 𝕜 n (fun y => c • f y) univ x

tactic: exact hf.const_smul c
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
f : E → F
x : E
c : R
hf : ContDiffWithinAt 𝕜 n f univ x
⊢ ContDiffWithinAt 𝕜 n (fun y => c • f y) univ x
state_after: no goals
Theorem: FirstOrder.Language.Embedding.toHom_injective
File: Mathlib/ModelTheory/Basic.lean

tactic: intro f f' h
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
⊢ Function.Injective fun x => x.toHom
state_after: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f f' : M ↪[L] N
h : (fun x => x.toHom) f = (fun x => x.toHom) f'
⊢ f = f'

tactic: ext
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f f' : M ↪[L] N
h : (fun x => x.toHom) f = (fun x => x.toHom) f'
⊢ f = f'
state_after: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f f' : M ↪[L] N
h : (fun x => x.toHom) f = (fun x => x.toHom) f'
x✝ : M
⊢ f x✝ = f' x✝

tactic: exact congr_fun (congr_arg (↑) h) _
state_before: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f f' : M ↪[L] N
h : (fun x => x.toHom) f = (fun x => x.toHom) f'
x✝ : M
⊢ f x✝ = f' x✝
state_after: no goals
Theorem: LinearMap.surjective_rangeRestrict
File: Mathlib/Algebra/Module/Submodule/Range.lean

tactic: rw [← range_eq_top, range_rangeRestrict]
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring R₂
inst✝⁸ : Semiring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
⊢ Surjective ⇑f.rangeRestrict
state_after: no goals
Theorem: HasStrictDerivAt.rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: convert (hasStrictFDerivAt_rpow_of_pos ((fun x => (f x, g x)) x) h).comp_hasStrictDerivAt x
  (hf.prod hg) using 1
state_before: x y z : ℝ
f g : ℝ → ℝ
f' g' : ℝ
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
h : 0 < f x
⊢ HasStrictDerivAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * log (f x)) x
state_after: case h.e'_7
x y z : ℝ
f g : ℝ → ℝ
f' g' : ℝ
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * log (f x) =
    ((((fun x => (f x, g x)) x).2 * ((fun x => (f x, g x)) x).1 ^ (((fun x => (f x, g x)) x).2 - 1)) •
          ContinuousLinearMap.fst ℝ ℝ ℝ +
        (((fun x => (f x, g x)) x).1 ^ ((fun x => (f x, g x)) x).2 * log ((fun x => (f x, g x)) x).1) •
          ContinuousLinearMap.snd ℝ ℝ ℝ)
      (f', g')

tactic: simp [mul_assoc, mul_comm, mul_left_comm]
state_before: case h.e'_7
x y z : ℝ
f g : ℝ → ℝ
f' g' : ℝ
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * log (f x) =
    ((((fun x => (f x, g x)) x).2 * ((fun x => (f x, g x)) x).1 ^ (((fun x => (f x, g x)) x).2 - 1)) •
          ContinuousLinearMap.fst ℝ ℝ ℝ +
        (((fun x => (f x, g x)) x).1 ^ ((fun x => (f x, g x)) x).2 * log ((fun x => (f x, g x)) x).1) •
          ContinuousLinearMap.snd ℝ ℝ ℝ)
      (f', g')
state_after: no goals
Theorem: LieModule.isLieAbelian_of_ker_traceForm_eq_bot
File: Mathlib/Algebra/Lie/TraceForm.lean

tactic: simpa only [← disjoint_lowerCentralSeries_maxTrivSubmodule_iff R L L, disjoint_iff_inf_le,
  LieIdeal.coe_to_lieSubalgebra_to_submodule, LieSubmodule.coeSubmodule_eq_bot_iff, h]
  using lowerCentralSeries_one_inf_center_le_ker_traceForm R L M
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : LieAlgebra.IsNilpotent R L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
h : LinearMap.ker (traceForm R L M) = ⊥
⊢ IsLieAbelian L
state_after: no goals
Theorem: Stream'.mem_interleave_left
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, get_interleave_left]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s₁ s₂ : Stream' α
x✝ : a ∈ s₁
n : ℕ
h : (fun b => a = b) (s₁.get n)
⊢ (fun b => a = b) ((s₁ ⋈ s₂).get (2 * n))
state_after: no goals
Theorem: Set.biUnion_and'
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [iUnion_and, @iUnion_comm _ ι]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
p : ι' → Prop
q : ι → ι' → Prop
s : (x : ι) → (y : ι') → p y ∧ q x y → Set α
⊢ ⋃ x, ⋃ y, ⋃ (h : p y ∧ q x y), s x y h = ⋃ y, ⋃ (hy : p y), ⋃ x, ⋃ (hx : q x y), s x y ⋯
state_after: no goals
Theorem: List.lookmap_map_eq
File: Mathlib/Data/List/Basic.lean

tactic: cases' h' : f a with b
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
g : α → β
h : ∀ (a b : α), b ∈ f a → g a = g b
a : α
l : List α
⊢ map g (lookmap f (a :: l)) = map g (a :: l)
state_after: case none
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
g : α → β
h : ∀ (a b : α), b ∈ f a → g a = g b
a : α
l : List α
h' : f a = none
⊢ map g (lookmap f (a :: l)) = map g (a :: l)

case some
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
g : α → β
h : ∀ (a b : α), b ∈ f a → g a = g b
a : α
l : List α
b : α
h' : f a = some b
⊢ map g (lookmap f (a :: l)) = map g (a :: l)

tactic: simpa [h'] using lookmap_map_eq _ h l
state_before: case none
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
g : α → β
h : ∀ (a b : α), b ∈ f a → g a = g b
a : α
l : List α
h' : f a = none
⊢ map g (lookmap f (a :: l)) = map g (a :: l)
state_after: no goals

tactic: simp [lookmap_cons_some _ _ h', h _ _ h']
state_before: case some
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
g : α → β
h : ∀ (a b : α), b ∈ f a → g a = g b
a : α
l : List α
b : α
h' : f a = some b
⊢ map g (lookmap f (a :: l)) = map g (a :: l)
state_after: no goals
Theorem: Real.strictConvexOn_mul_log
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

tactic: refine strictConvexOn_of_deriv2_pos (convex_Ici 0) (continuous_mul_log.continuousOn) ?_
state_before: ⊢ StrictConvexOn ℝ (Set.Ici 0) fun x => x * log x
state_after: ⊢ ∀ x ∈ interior (Set.Ici 0), 0 < deriv^[2] (fun x => x * log x) x

tactic: intro x hx
state_before: ⊢ ∀ x ∈ interior (Set.Ici 0), 0 < deriv^[2] (fun x => x * log x) x
state_after: x : ℝ
hx : x ∈ interior (Set.Ici 0)
⊢ 0 < deriv^[2] (fun x => x * log x) x

tactic: simp only [Set.nonempty_Iio, interior_Ici', Set.mem_Ioi] at hx
state_before: x : ℝ
hx : x ∈ interior (Set.Ici 0)
⊢ 0 < deriv^[2] (fun x => x * log x) x
state_after: x : ℝ
hx : 0 < x
⊢ 0 < deriv^[2] (fun x => x * log x) x

tactic: rw [deriv2_mul_log hx.ne']
state_before: x : ℝ
hx : 0 < x
⊢ 0 < deriv^[2] (fun x => x * log x) x
state_after: x : ℝ
hx : 0 < x
⊢ 0 < x⁻¹

tactic: positivity
state_before: x : ℝ
hx : 0 < x
⊢ 0 < x⁻¹
state_after: no goals
Theorem: Filter.Tendsto.atTop_nsmul_neg_const
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa using hf.atTop_nsmul_const (neg_pos.2 hr)
state_before: α : Type u_1
R : Type u_2
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℕ
hr : r < 0
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x • r) l atBot
state_after: no goals
Theorem: add_sub_div_two_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [← div_sub_div_same, sub_eq_add_neg, add_comm (b / 2), ← add_assoc, ← sub_eq_add_neg, ←
  lt_sub_iff_add_lt, sub_self_div_two, sub_self_div_two, div_lt_div_right (zero_lt_two' α)]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h : a < b
⊢ a + (b - a) / 2 < b
state_after: no goals
Theorem: Matrix.fromBlocks_smul
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i j
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : SMul R α
x : R
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
⊢ x • fromBlocks A B C D = fromBlocks (x • A) (x • B) (x • C) (x • D)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : SMul R α
x : R
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
i : n ⊕ o
j : l ⊕ m
⊢ (x • fromBlocks A B C D) i j = fromBlocks (x • A) (x • B) (x • C) (x • D) i j

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> simp [fromBlocks]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : SMul R α
x : R
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
i : n ⊕ o
j : l ⊕ m
⊢ (x • fromBlocks A B C D) i j = fromBlocks (x • A) (x • B) (x • C) (x • D) i j
state_after: no goals
Theorem: Finset.sum_range_id
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [← sum_range_id_mul_two n, Nat.mul_div_cancel _ zero_lt_two]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f : α → M
n : ℕ
⊢ ∑ i ∈ range n, i = n * (n - 1) / 2
state_after: no goals
Theorem: MeasureTheory.Measure.integral_condKernel
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: conv_rhs => rw [← compProd_fst_condKernel ρ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : Integrable f ρ
⊢ ∫ (b : β), ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω), f x ∂ρ
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : Integrable f ρ
⊢ ∫ (b : β), ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω), f x ∂ρ.fst ⊗ₘ ρ.condKernel

tactic: rw [← compProd_fst_condKernel ρ] at hf
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : Integrable f ρ
⊢ ∫ (b : β), ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω), f x ∂ρ.fst ⊗ₘ ρ.condKernel
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : Integrable f (ρ.fst ⊗ₘ ρ.condKernel)
⊢ ∫ (b : β), ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω), f x ∂ρ.fst ⊗ₘ ρ.condKernel

tactic: rw [integral_compProd hf]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : Integrable f (ρ.fst ⊗ₘ ρ.condKernel)
⊢ ∫ (b : β), ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω), f x ∂ρ.fst ⊗ₘ ρ.condKernel
state_after: no goals
Theorem: AddLECancellable.tsub_tsub_assoc
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_assoc, add_tsub_cancel_of_le h₂, tsub_add_cancel_of_le h₁]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hbc : AddLECancellable (b - c)
h₁ : b ≤ a
h₂ : c ≤ b
⊢ a = a - b + c + (b - c)
state_after: no goals
Theorem: Prod.swap_iSup
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [iSup, swap_sSup, ← range_comp, Function.comp]
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✝¹ : SupSet α
inst✝ : SupSet β
f : ι → α × β
⊢ (iSup f).swap = ⨆ i, (f i).swap
state_after: no goals
Theorem: covBy_iff_Ioo_eq
File: Mathlib/Order/Cover.lean

tactic: simp [eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a b c : α
⊢ (∀ ⦃c : α⦄, a < c → ¬c < b) ↔ Ioo a b = ∅
state_after: no goals
Theorem: Ordinal.bsup_eq_blsub_or_succ_bsup_eq_blsub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← sup_eq_bsup, ← lsub_eq_blsub]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ o.bsup f = o.blsub f ∨ succ (o.bsup f) = o.blsub f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ sup (o.familyOfBFamily f) = lsub (o.familyOfBFamily f) ∨ succ (sup (o.familyOfBFamily f)) = lsub (o.familyOfBFamily f)

tactic: exact sup_eq_lsub_or_sup_succ_eq_lsub _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ sup (o.familyOfBFamily f) = lsub (o.familyOfBFamily f) ∨ succ (sup (o.familyOfBFamily f)) = lsub (o.familyOfBFamily f)
state_after: no goals