1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.fromRows_fromColumn_eq_fromBlocks
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

tactic: ext (_ | _) (_ | _) <;> simp
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
B₁₁ : Matrix m₁ n₁ R
B₁₂ : Matrix m₁ n₂ R
B₂₁ : Matrix m₂ n₁ R
B₂₂ : Matrix m₂ n₂ R
⊢ (B₁₁.fromColumns B₁₂).fromRows (B₂₁.fromColumns B₂₂) = fromBlocks B₁₁ B₁₂ B₂₁ B₂₂
state_after: no goals
Theorem: Set.uIcc_comm
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simp_rw [uIcc, inf_comm, sup_comm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Lattice α
inst✝ : Lattice β
a✝ a₁ a₂ b✝ b₁ b₂ c x a b : α
⊢ [[a, b]] = [[b, a]]
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.top_caratheodory
File: Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean

tactic: simp [ht]
state_before: α : Type u_1
s : Set α
x✝ : MeasurableSet s
t : Set α
ht : t = ∅
⊢ ⊤ (t ∩ s) + ⊤ (t \ s) ≤ ⊤ t
state_after: no goals

tactic: simp only [ht, top_apply, le_top]
state_before: α : Type u_1
s : Set α
x✝ : MeasurableSet s
t : Set α
ht : t.Nonempty
⊢ ⊤ (t ∩ s) + ⊤ (t \ s) ≤ ⊤ t
state_after: no goals
Theorem: Ideal.span_singleton_mul_left_inj
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [le_antisymm_iff, span_singleton_mul_left_mono hx]
state_before: R : Type u
ι : Type u_1
inst✝¹ : CommSemiring R
I J K L : Ideal R
inst✝ : IsDomain R
x : R
hx : x ≠ 0
⊢ I * span {x} = J * span {x} ↔ I = J
state_after: no goals
Theorem: List.sublistsLen_succ_cons
File: Mathlib/Data/List/Sublists.lean

tactic: rw [sublistsLen, sublistsLenAux, sublistsLenAux_eq, sublistsLenAux_eq, map_id,
    append_nil]
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) (a :: l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)
state_after: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) l ++ map (id ∘ cons a) (sublistsLen n l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) l ++ map (id ∘ cons a) (sublistsLen n l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)
state_after: no goals
Theorem: HomologicalComplex.cylinder.map_ι₀_eq_map_ι₁
File: Mathlib/Algebra/Homology/HomotopyCofiber.lean

tactic: have : IsIso (H.map (cylinder.π K)) := hH _ ⟨homotopyEquiv K hc, rfl⟩
state_before: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
inst✝⁵ : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝⁴ : HasHomotopyCofiber φ
inst✝³ : DecidableRel c.Rel
inst✝² : ∀ (i : ι), HasBinaryBiproduct (K.X i) (K.X i)
inst✝¹ : HasHomotopyCofiber (biprod.lift (𝟙 K) (-𝟙 K))
hc : ∀ (j : ι), ∃ i, c.Rel i j
D : Type u_3
inst✝ : Category.{u_4, u_3} D
H : HomologicalComplex C c ⥤ D
hH : (homotopyEquivalences C c).IsInvertedBy H
⊢ H.map (ι₀ K) = H.map (ι₁ K)
state_after: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
inst✝⁵ : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝⁴ : HasHomotopyCofiber φ
inst✝³ : DecidableRel c.Rel
inst✝² : ∀ (i : ι), HasBinaryBiproduct (K.X i) (K.X i)
inst✝¹ : HasHomotopyCofiber (biprod.lift (𝟙 K) (-𝟙 K))
hc : ∀ (j : ι), ∃ i, c.Rel i j
D : Type u_3
inst✝ : Category.{u_4, u_3} D
H : HomologicalComplex C c ⥤ D
hH : (homotopyEquivalences C c).IsInvertedBy H
this : IsIso (H.map (π K))
⊢ H.map (ι₀ K) = H.map (ι₁ K)

tactic: simp only [← cancel_mono (H.map (cylinder.π K)), ← H.map_comp, ι₀_π, H.map_id, ι₁_π]
state_before: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
inst✝⁵ : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝⁴ : HasHomotopyCofiber φ
inst✝³ : DecidableRel c.Rel
inst✝² : ∀ (i : ι), HasBinaryBiproduct (K.X i) (K.X i)
inst✝¹ : HasHomotopyCofiber (biprod.lift (𝟙 K) (-𝟙 K))
hc : ∀ (j : ι), ∃ i, c.Rel i j
D : Type u_3
inst✝ : Category.{u_4, u_3} D
H : HomologicalComplex C c ⥤ D
hH : (homotopyEquivalences C c).IsInvertedBy H
this : IsIso (H.map (π K))
⊢ H.map (ι₀ K) = H.map (ι₁ K)
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.cocycle_snd_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp only [t'_snd_snd, t'_fst_fst_fst, t'_fst_snd]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.snd = pullback.snd ≫ pullback.snd
state_after: no goals
Theorem: Matroid.setOf_base_eq_maximals_setOf_indep
File: Mathlib/Data/Matroid/Basic.lean

tactic: ext B
state_before: α : Type u_1
M : Matroid α
⊢ {B | M.Base B} = maximals (fun x x_1 => x ⊆ x_1) {I | M.Indep I}
state_after: case h
α : Type u_1
M : Matroid α
B : Set α
⊢ B ∈ {B | M.Base B} ↔ B ∈ maximals (fun x x_1 => x ⊆ x_1) {I | M.Indep I}

tactic: rw [mem_maximals_setOf_iff, mem_setOf, base_iff_maximal_indep]
state_before: case h
α : Type u_1
M : Matroid α
B : Set α
⊢ B ∈ {B | M.Base B} ↔ B ∈ maximals (fun x x_1 => x ⊆ x_1) {I | M.Indep I}
state_after: no goals
Theorem: Complex.sin_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, sin_add, sin_neg, cos_neg]
state_before: x y : ℂ
⊢ sin (x - y) = sin x * cos y - cos x * sin y
state_after: no goals
Theorem: EReal.coe_real_ereal_eq_coe_toNNReal_sub_coe_toNNReal
File: Mathlib/Data/Real/EReal.lean

tactic: rcases le_total 0 x with (h | h)
state_before: x : ℝ
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal
state_after: case inl
x : ℝ
h : 0 ≤ x
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal

case inr
x : ℝ
h : x ≤ 0
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal

tactic: lift x to ℝ≥0 using h
state_before: case inl
x : ℝ
h : 0 ≤ x
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal
state_after: case inl.intro
x : ℝ≥0
⊢ ↑↑x = ↑↑(↑x).toNNReal - ↑↑(-↑x).toNNReal

tactic: rw [Real.toNNReal_of_nonpos (neg_nonpos.mpr x.coe_nonneg), Real.toNNReal_coe, ENNReal.coe_zero,
  coe_ennreal_zero, sub_zero]
state_before: case inl.intro
x : ℝ≥0
⊢ ↑↑x = ↑↑(↑x).toNNReal - ↑↑(-↑x).toNNReal
state_after: case inl.intro
x : ℝ≥0
⊢ ↑↑x = ↑↑x

tactic: rfl
state_before: case inl.intro
x : ℝ≥0
⊢ ↑↑x = ↑↑x
state_after: no goals

tactic: rw [Real.toNNReal_of_nonpos h, ENNReal.coe_zero, coe_ennreal_zero, coe_nnreal_eq_coe_real,
  Real.coe_toNNReal, zero_sub, coe_neg, neg_neg]
state_before: case inr
x : ℝ
h : x ≤ 0
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal
state_after: case inr.hr
x : ℝ
h : x ≤ 0
⊢ 0 ≤ -x

tactic: exact neg_nonneg.2 h
state_before: case inr.hr
x : ℝ
h : x ≤ 0
⊢ 0 ≤ -x
state_after: no goals
Theorem: Urysohns.CU.approx_of_nmem_U
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: induction' n with n ihn generalizing c
state_before: X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
n : ℕ
x : X
hx : x ∉ c.U
⊢ approx n c x = 1
state_after: case zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
c : CU P
hx : x ∉ c.U
⊢ approx 0 c x = 1

case succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ approx (n + 1) c x = 1

tactic: rw [← mem_compl_iff] at hx
state_before: case zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
c : CU P
hx : x ∉ c.U
⊢ approx 0 c x = 1
state_after: case zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
c : CU P
hx : x ∈ c.Uᶜ
⊢ approx 0 c x = 1

tactic: exact indicator_of_mem hx _
state_before: case zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
c : CU P
hx : x ∈ c.Uᶜ
⊢ approx 0 c x = 1
state_after: no goals

tactic: simp only [approx]
state_before: case succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ approx (n + 1) c x = 1
state_after: case succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ midpoint ℝ (approx n c.left x) (approx n c.right x) = 1

tactic: rw [ihn, ihn, midpoint_self]
state_before: case succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ midpoint ℝ (approx n c.left x) (approx n c.right x) = 1
state_after: case succ.hx
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ x ∉ c.right.U

case succ.hx
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ x ∉ c.left.U

tactic: exacts [hx, fun hU => hx <| c.left_U_subset hU]
state_before: case succ.hx
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ x ∉ c.right.U

case succ.hx
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ x ∉ c.left.U
state_after: no goals
Theorem: Function.Bijective.cauchySeq_comp_iff
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine ⟨fun H => ?_, fun H => H.comp_injective hf.injective⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : ℕ → ℕ
hf : Bijective f
u : ℕ → α
⊢ CauchySeq (u ∘ f) ↔ CauchySeq u
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : ℕ → ℕ
hf : Bijective f
u : ℕ → α
H : CauchySeq (u ∘ f)
⊢ CauchySeq u

tactic: lift f to ℕ ≃ ℕ using hf
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : ℕ → ℕ
hf : Bijective f
u : ℕ → α
H : CauchySeq (u ∘ f)
⊢ CauchySeq u
state_after: case intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
u : ℕ → α
f : ℕ ≃ ℕ
H : CauchySeq (u ∘ ⇑f)
⊢ CauchySeq u
Theorem: Turing.PartrecToTM2.contSupp_cons₁
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [codeSupp, codeSupp', contSupp, Finset.union_assoc]
state_before: fs : Code
k : Cont'
⊢ contSupp (Cont'.cons₁ fs k) =
    trStmts₁
        (move₂ (fun x => false) main aux
          (move₂ (fun s => decide (s = Γ'.consₗ)) stack main
            (move₂ (fun x => false) aux stack (trNormal fs k.cons₂)))) ∪
      codeSupp fs k.cons₂
state_after: no goals
Theorem: Real.Angle.neg_pi_div_two_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_injective.ne_iff, toReal_neg_pi_div_two, toReal_zero]
state_before: ⊢ ↑(-π / 2) ≠ 0
state_after: ⊢ -π / 2 ≠ 0

tactic: exact div_ne_zero (neg_ne_zero.2 Real.pi_ne_zero) two_ne_zero
state_before: ⊢ -π / 2 ≠ 0
state_after: no goals
Theorem: SimpleGraph.Subgraph.IsMatching.even_card
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: classical
rw [isMatching_iff_forall_degree] at h
use M.coe.edgeFinset.card
rw [← two_mul, ← M.coe.sum_degrees_eq_twice_card_edges]
convert_to _ = Finset.sum Finset.univ fun v => SimpleGraph.degree (Subgraph.coe M) v using 3
simp [h, Finset.card_univ]
state_before: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : M.IsMatching
⊢ Even M.verts.toFinset.card
state_after: no goals

tactic: rw [isMatching_iff_forall_degree] at h
state_before: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : M.IsMatching
⊢ Even M.verts.toFinset.card
state_after: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ Even M.verts.toFinset.card

tactic: use M.coe.edgeFinset.card
state_before: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ Even M.verts.toFinset.card
state_after: case h
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ M.verts.toFinset.card = M.coe.edgeFinset.card + M.coe.edgeFinset.card

tactic: rw [← two_mul, ← M.coe.sum_degrees_eq_twice_card_edges]
state_before: case h
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ M.verts.toFinset.card = M.coe.edgeFinset.card + M.coe.edgeFinset.card
state_after: case h
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ M.verts.toFinset.card = ∑ v : ↑M.verts, M.coe.degree v

tactic: convert_to _ = Finset.sum Finset.univ fun v => SimpleGraph.degree (Subgraph.coe M) v using 3
state_before: case h
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ M.verts.toFinset.card = ∑ v : ↑M.verts, M.coe.degree v
state_after: case h.convert_2
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ M.verts.toFinset.card = ∑ v : ↑M.verts, M.coe.degree v

tactic: simp [h, Finset.card_univ]
state_before: case h.convert_2
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
inst✝ : Fintype ↑M.verts
h : ∀ v ∈ M.verts, M.degree v = 1
⊢ M.verts.toFinset.card = ∑ v : ↑M.verts, M.coe.degree v
state_after: no goals
Theorem: PFunctor.M.mk_inj
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: rw [← dest_mk x, h, dest_mk]
state_before: F : PFunctor.{u}
X : Type u_1
f : X → ↑F X
x y : ↑F F.M
h : M.mk x = M.mk y
⊢ x = y
state_after: no goals
Theorem: Multipliable.countable_mulSupport
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: simpa only [ker_nhds] using hf.tendsto_cofinite_one.countable_compl_preimage_ker
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝⁴ : TopologicalSpace G
inst✝³ : CommGroup G
inst✝² : TopologicalGroup G
f : α → G
inst✝¹ : FirstCountableTopology G
inst✝ : T1Space G
hf : Multipliable f
⊢ (mulSupport f).Countable
state_after: no goals
Theorem: Stream'.WSeq.ofList_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ Seq.map some ↑(a :: l) = Seq.cons (some a) (Seq.map some ↑l)
state_after: no goals
Theorem: MeasureTheory.lintegral_map_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← iSup_lintegral_measurable_le_eq_lintegral, ← iSup_lintegral_measurable_le_eq_lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
⊢ ∫⁻ (a : β), f a ∂Measure.map g μ ≤ ∫⁻ (a : α), f (g a) ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
⊢ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f), ∫⁻ (a : β), g_1 a ∂Measure.map g μ ≤
    ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ fun a => f (g a)), ∫⁻ (a : α), g_1 a ∂μ

tactic: refine iSup₂_le fun i hi => iSup_le fun h'i => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
⊢ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f), ∫⁻ (a : β), g_1 a ∂Measure.map g μ ≤
    ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ fun a => f (g a)), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
i : β → ℝ≥0∞
hi : Measurable i
h'i : i ≤ f
⊢ ∫⁻ (a : β), i a ∂Measure.map g μ ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ fun a => f (g a)), ∫⁻ (a : α), g_1 a ∂μ

tactic: refine le_iSup₂_of_le (i ∘ g) (hi.comp hg) ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
i : β → ℝ≥0∞
hi : Measurable i
h'i : i ≤ f
⊢ ∫⁻ (a : β), i a ∂Measure.map g μ ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ fun a => f (g a)), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
i : β → ℝ≥0∞
hi : Measurable i
h'i : i ≤ f
⊢ ∫⁻ (a : β), i a ∂Measure.map g μ ≤ ⨆ (_ : i ∘ g ≤ fun a => f (g a)), ∫⁻ (a : α), (i ∘ g) a ∂μ

tactic: exact le_iSup_of_le (fun x => h'i (g x)) (le_of_eq (lintegral_map hi hg))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
hg : Measurable g
i : β → ℝ≥0∞
hi : Measurable i
h'i : i ≤ f
⊢ ∫⁻ (a : β), i a ∂Measure.map g μ ≤ ⨆ (_ : i ∘ g ≤ fun a => f (g a)), ∫⁻ (a : α), (i ∘ g) a ∂μ
state_after: no goals
Theorem: iSup_prod
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [iSup_le_iff, Prod.forall]
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 : α
f : β × γ → α
c : α
⊢ ⨆ x, f x ≤ c ↔ ⨆ i, ⨆ j, f (i, j) ≤ c
state_after: no goals
Theorem: OpenEmbedding.open_iff_image_open
File: Mathlib/Topology/Maps.lean

tactic: convert ← h.preimage hf.toEmbedding.continuous
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : OpenEmbedding f
s : Set X
h : IsOpen (f '' s)
⊢ IsOpen s
state_after: case h.e'_3
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : OpenEmbedding f
s : Set X
h : IsOpen (f '' s)
⊢ f ⁻¹' (f '' s) = s

tactic: apply preimage_image_eq _ hf.inj
state_before: case h.e'_3
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : OpenEmbedding f
s : Set X
h : IsOpen (f '' s)
⊢ f ⁻¹' (f '' s) = s
state_after: no goals
Theorem: Nat.cauchy_induction'
File: Mathlib/Order/Interval/Finset/Nat.lean

tactic: apply Nat.decreasing_induction_of_infinite h fun hf => _
state_before: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
⊢ P n
state_after: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
⊢ {x | P x}.Finite → False

tactic: intro hf
state_before: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
⊢ {x | P x}.Finite → False
state_after: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : {x | P x}.Finite
⊢ False

tactic: obtain ⟨m, hP, hm⟩ := hf.exists_maximal_wrt id _ ⟨seed, hs⟩
state_before: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : {x | P x}.Finite
⊢ False
state_after: case intro.intro
a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : {x | P x}.Finite
m : ℕ
hP : m ∈ {x | P x}
hm : ∀ a' ∈ {x | P x}, id m ≤ id a' → id m = id a'
⊢ False

tactic: obtain ⟨y, hl, hy⟩ := hi m (le_of_not_lt fun hl => hl.ne <| hm seed hs hl.le) hP
state_before: case intro.intro
a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : {x | P x}.Finite
m : ℕ
hP : m ∈ {x | P x}
hm : ∀ a' ∈ {x | P x}, id m ≤ id a' → id m = id a'
⊢ False
state_after: case intro.intro.intro.intro
a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : {x | P x}.Finite
m : ℕ
hP : m ∈ {x | P x}
hm : ∀ a' ∈ {x | P x}, id m ≤ id a' → id m = id a'
y : ℕ
hl : m < y
hy : P y
⊢ False

tactic: exact hl.ne (hm y hy hl.le)
state_before: case intro.intro.intro.intro
a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : {x | P x}.Finite
m : ℕ
hP : m ∈ {x | P x}
hm : ∀ a' ∈ {x | P x}, id m ≤ id a' → id m = id a'
y : ℕ
hl : m < y
hy : P y
⊢ False
state_after: no goals
Theorem: List.head!_mem_head?
File: Mathlib/Data/List/Basic.lean

tactic: contradiction
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
h : [] ≠ []
⊢ [].head! ∈ [].head?
state_after: no goals
Theorem: Real.cos_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, cos_add, sin_neg, cos_neg]
state_before: x y : ℝ
⊢ cos (x - y) = cos x * cos y + sin x * sin y
state_after: no goals
Theorem: Real.Angle.coe_abs_toReal_of_sign_nonneg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [abs_eq_self.2 (toReal_nonneg_iff_sign_nonneg.2 h), coe_toReal]
state_before: θ : Angle
h : 0 ≤ θ.sign
⊢ ↑|θ.toReal| = θ
state_after: no goals
Theorem: Fin.castSucc_pos'
File: Mathlib/Data/Fin/Basic.lean

tactic: simpa [lt_iff_val_lt_val] using h
state_before: n m : ℕ
inst✝ : NeZero n
i : Fin n
h : 0 < i
⊢ 0 < i.castSucc
state_after: no goals