1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HomologicalComplex.from_single_hom_ext
File: Mathlib/Algebra/Homology/Single.lean

tactic: ext i
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
⊢ f = g
state_after: case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
i : ι
⊢ f.f i = g.f i

tactic: by_cases h : i = j
state_before: case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
i : ι
⊢ f.f i = g.f i
state_after: case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
i : ι
h : i = j
⊢ f.f i = g.f i

case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
i : ι
h : ¬i = j
⊢ f.f i = g.f i

tactic: subst h
state_before: case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
i : ι
h : i = j
⊢ f.f i = g.f i
state_after: case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
A : V
i : ι
f g : (single V c i).obj A ⟶ K
hfg : f.f i = g.f i
⊢ f.f i = g.f i

tactic: exact hfg
state_before: case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
A : V
i : ι
f g : (single V c i).obj A ⟶ K
hfg : f.f i = g.f i
⊢ f.f i = g.f i
state_after: no goals

tactic: apply (isZero_single_obj_X c j A i h).eq_of_src
state_before: case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : (single V c j).obj A ⟶ K
hfg : f.f j = g.f j
i : ι
h : ¬i = j
⊢ f.f i = g.f i
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.equation_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp only [equation_iff, hPz, add_zero, mul_zero, zero_pow <| OfNat.ofNat_ne_zero _, sub_eq_zero]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.Equation P ↔ P y ^ 2 = P x ^ 3
state_after: no goals
Theorem: List.foldl_join
File: Mathlib/Data/List/Basic.lean

tactic: simp only [join, foldl_append, foldl_cons, foldl_join f (foldl f a l) L]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → α
a : α
l : List β
L : List (List β)
⊢ foldl f a (l :: L).join = foldl (foldl f) a (l :: L)
state_after: no goals
Theorem: MeasurableSpace.iUnion_mem_generateMeasurableRec
File: Mathlib/MeasureTheory/MeasurableSpace/Card.lean

tactic: unfold generateMeasurableRec
state_before: α : Type u
s : Set (Set α)
i : (Quotient.out (aleph 1).ord).α
f : ℕ → Set α
hf : ∀ (n : ℕ), ∃ j < i, f n ∈ generateMeasurableRec s j
⊢ ⋃ n, f n ∈ generateMeasurableRec s i
state_after: α : Type u
s : Set (Set α)
i : (Quotient.out (aleph 1).ord).α
f : ℕ → Set α
hf : ∀ (n : ℕ), ∃ j < i, f n ∈ generateMeasurableRec s j
⊢ ⋃ n, f n ∈
    let i := i;
    let S := ⋃ j, generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)

tactic: exact mem_union_right _ ⟨fun n => ⟨f n, let ⟨j, hj, hf⟩ := hf n; mem_iUnion.2 ⟨⟨j, hj⟩, hf⟩⟩, rfl⟩
state_before: α : Type u
s : Set (Set α)
i : (Quotient.out (aleph 1).ord).α
f : ℕ → Set α
hf : ∀ (n : ℕ), ∃ j < i, f n ∈ generateMeasurableRec s j
⊢ ⋃ n, f n ∈
    let i := i;
    let S := ⋃ j, generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)
state_after: no goals
Theorem: CategoryTheory.Limits.inr_of_isLimit
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: apply ht.uniq (BinaryFan.mk 0 (𝟙 Y))
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
t : BinaryBicone X Y
ht : IsLimit t.toCone
⊢ t.inr = ht.lift (BinaryFan.mk 0 (𝟙 Y))
state_after: case x
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
t : BinaryBicone X Y
ht : IsLimit t.toCone
⊢ ∀ (j : Discrete WalkingPair), t.inr ≫ t.toCone.π.app j = (BinaryFan.mk 0 (𝟙 Y)).π.app j

tactic: rintro ⟨⟨⟩⟩ <;> dsimp <;> simp
state_before: case x
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
t : BinaryBicone X Y
ht : IsLimit t.toCone
⊢ ∀ (j : Discrete WalkingPair), t.inr ≫ t.toCone.π.app j = (BinaryFan.mk 0 (𝟙 Y)).π.app j
state_after: no goals
Theorem: Composition.length_sigmaCompositionAux
File: Mathlib/Analysis/Analytic/Composition.lean

tactic: rw [getElem_map_rev List.length, getElem_of_eq (map_length_splitWrtComposition _ _)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition a.length
i : Fin b.length
⊢ (a.blocks.splitWrtComposition b)[↑i].length = b.blocksFun i
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition a.length
i : Fin b.length
⊢ b.blocks[↑i] = b.blocksFun i

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition a.length
i : Fin b.length
⊢ b.blocks[↑i] = b.blocksFun i
state_after: no goals
Theorem: CategoryTheory.StructuredArrow.homMk'_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ f = mk (f.hom ≫ T.map (𝟙 f.right))
state_after: no goals

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ f.homMk' (𝟙 f.right) = eqToHom ⋯
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (f.homMk' (𝟙 f.right)).right = (eqToHom ⋯).right

tactic: simp [eqToHom_right]
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (f.homMk' (𝟙 f.right)).right = (eqToHom ⋯).right
state_after: no goals
Theorem: GenLoop.copy_eq
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: ext x
state_before: N : Type u_1
X : Type u_2
inst✝ : TopologicalSpace X
x : X
f : ↑(Ω^ N X x)
g : (N → ↑I) → X
h : g = ⇑f
⊢ copy f g h = f
state_after: case H
N : Type u_1
X : Type u_2
inst✝ : TopologicalSpace X
x✝ : X
f : ↑(Ω^ N X x✝)
g : (N → ↑I) → X
h : g = ⇑f
x : N → ↑I
⊢ (copy f g h) x = f x

tactic: exact congr_fun h x
state_before: case H
N : Type u_1
X : Type u_2
inst✝ : TopologicalSpace X
x✝ : X
f : ↑(Ω^ N X x✝)
g : (N → ↑I) → X
h : g = ⇑f
x : N → ↑I
⊢ (copy f g h) x = f x
state_after: no goals
Theorem: Metric.isOpen_singleton_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: simp [isOpen_iff, subset_singleton_iff, mem_ball]
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α✝
x✝ y z : α✝
δ ε ε₁ ε₂ : ℝ
s : Set α✝
α : Type u_3
inst✝ : PseudoMetricSpace α
x : α
⊢ IsOpen {x} ↔ ∃ ε > 0, ∀ (y : α), dist y x < ε → y = x
state_after: no goals
Theorem: Equiv.removeNone_aux_some
File: Mathlib/Logic/Equiv/Option.lean

tactic: simp [removeNone_aux, Option.isSome_iff_exists.mpr h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : ∃ x', e (some x) = some x'
⊢ some (e.removeNone_aux x) = e (some x)
state_after: no goals
Theorem: ProbabilityTheory.ofReal_cdf
File: Mathlib/Probability/Cdf.lean

tactic: have := IsProbabilityMeasure.toIsFiniteMeasure (Measure.prod (Measure.dirac ()) μ)
state_before: μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)
state_after: μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
this : IsFiniteMeasure ((Measure.dirac ()).prod μ)
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)

tactic: have h := lintegral_condCDF ((Measure.dirac Unit.unit).prod μ) x
state_before: μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
this : IsFiniteMeasure ((Measure.dirac ()).prod μ)
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)
state_after: μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
this : IsFiniteMeasure ((Measure.dirac ()).prod μ)
h :
  ∫⁻ (a : Unit), ENNReal.ofReal (↑(condCDF ((Measure.dirac ()).prod μ) a) x) ∂((Measure.dirac ()).prod μ).fst =
    ((Measure.dirac ()).prod μ) (univ ×ˢ Iic x)
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)

tactic: simpa only [MeasureTheory.Measure.fst_prod, Measure.prod_prod, measure_univ, one_mul,
  lintegral_dirac] using h
state_before: μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
this : IsFiniteMeasure ((Measure.dirac ()).prod μ)
h :
  ∫⁻ (a : Unit), ENNReal.ofReal (↑(condCDF ((Measure.dirac ()).prod μ) a) x) ∂((Measure.dirac ()).prod μ).fst =
    ((Measure.dirac ()).prod μ) (univ ×ˢ Iic x)
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)
state_after: no goals
Theorem: MeasureTheory.Measure.ext
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [← trimmed, OuterMeasure.trim_congr (h _), trimmed]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : ∀ (s : Set α), MeasurableSet s → μ₁ s = μ₂ s
⊢ μ₁.toOuterMeasure = μ₂.toOuterMeasure
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.mkMetric_mono
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

tactic: convert @mkMetric_mono_smul X _ _ m₂ _ ENNReal.one_ne_top one_ne_zero _ <;> simp [*]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m₁ m₂ : ℝ≥0∞ → ℝ≥0∞
hle : m₁ ≤ᶠ[𝓝[≥] 0] m₂
⊢ mkMetric m₁ ≤ mkMetric m₂
state_after: no goals
Theorem: Associates.eq_of_prod_eq_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: have : a.prod.factors = b.prod.factors := by rw [h]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
⊢ a = b
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
this : a.prod.factors = b.prod.factors
⊢ a = b

tactic: rwa [prod_factors, prod_factors] at this
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
this : a.prod.factors = b.prod.factors
⊢ a = b
state_after: no goals

tactic: rw [h]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
⊢ a.prod.factors = b.prod.factors
state_after: no goals
Theorem: wellFoundedOn_devosMulRel
File: Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean

tactic: refine wellFounded_lt.onFun.wellFoundedOn.prod_lex_of_wellFoundedOn_fiber fun n ↦
  Set.WellFoundedOn.prod_lex_of_wellFoundedOn_fiber ?_ fun n ↦
    wellFounded_lt.onFun.wellFoundedOn
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
⊢ {x | x.1.Nonempty ∧ x.2.Nonempty}.WellFoundedOn DevosMulRel
state_after: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
n : ℕ
⊢ ({x | x.1.Nonempty ∧ x.2.Nonempty} ∩ (fun x => (x.1 * x.2).card) ⁻¹' {n}).WellFoundedOn
    ((fun x x_1 => x > x_1) on fun x => x.1.card + x.2.card)

tactic: exact wellFounded_lt.onFun.wellFoundedOn.mono' fun x hx y _ ↦ tsub_lt_tsub_left_of_le <|
  add_le_add ((card_le_card_mul_right _ hx.1.2).trans_eq hx.2) <|
    (card_le_card_mul_left _ hx.1.1).trans_eq hx.2
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
n : ℕ
⊢ ({x | x.1.Nonempty ∧ x.2.Nonempty} ∩ (fun x => (x.1 * x.2).card) ⁻¹' {n}).WellFoundedOn
    ((fun x x_1 => x > x_1) on fun x => x.1.card + x.2.card)
state_after: no goals
Theorem: Metric.hausdorffDist_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [hausdorffDist]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ hausdorffDist (closure s) (closure t) = hausdorffDist s t
state_after: no goals
Theorem: Complex.cos_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← cos_neg, neg_sub, cos_sub_pi_div_two]
state_before: x : ℂ
⊢ cos (↑π / 2 - x) = sin x
state_after: no goals
Theorem: StarConvex.add_right
File: Mathlib/Analysis/Convex/Star.lean

tactic: intro y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
⊢ StarConvex 𝕜 (x + z) ((fun x => x + z) '' s)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z y : E
hy : y ∈ (fun x => x + z) '' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • (x + z) + b • y ∈ (fun x => x + z) '' s

tactic: obtain ⟨y', hy', rfl⟩ := hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z y : E
hy : y ∈ (fun x => x + z) '' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • (x + z) + b • y ∈ (fun x => x + z) '' s
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ a • (x + z) + b • (fun x => x + z) y' ∈ (fun x => x + z) '' s

tactic: refine ⟨a • x + b • y', hs hy' ha hb hab, ?_⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ a • (x + z) + b • (fun x => x + z) y' ∈ (fun x => x + z) '' s
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ (fun x => x + z) (a • x + b • y') = a • (x + z) + b • (fun x => x + z) y'

tactic: rw [smul_add, smul_add, add_add_add_comm, ← add_smul, hab, one_smul]
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ (fun x => x + z) (a • x + b • y') = a • (x + z) + b • (fun x => x + z) y'
state_after: no goals
Theorem: ProbabilityTheory.kernel.measurable_singularPart_fun_right
File: Mathlib/Probability/Kernel/RadonNikodym.lean

tactic: change Measurable ((Function.uncurry fun a b ↦
  ENNReal.ofReal (rnDerivAux κ (κ + η) a b)
  - ENNReal.ofReal (1 - rnDerivAux κ (κ + η) a b) * rnDeriv κ η a b) ∘ (fun b ↦ (a, b)))
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
⊢ Measurable fun x => ↑(rnDerivAux κ (κ + η) a x).toNNReal - ↑(1 - rnDerivAux κ (κ + η) a x).toNNReal * rnDeriv κ η a x
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
⊢ Measurable
    ((Function.uncurry fun a b =>
        ENNReal.ofReal (rnDerivAux κ (κ + η) a b) - ENNReal.ofReal (1 - rnDerivAux κ (κ + η) a b) * rnDeriv κ η a b) ∘
      fun b => (a, b))

tactic: exact (measurable_singularPart_fun κ η).comp measurable_prod_mk_left
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
a : α
⊢ Measurable
    ((Function.uncurry fun a b =>
        ENNReal.ofReal (rnDerivAux κ (κ + η) a b) - ENNReal.ofReal (1 - rnDerivAux κ (κ + η) a b) * rnDeriv κ η a b) ∘
      fun b => (a, b))
state_after: no goals
Theorem: IsFractionRing.num_mul_den_eq_num_mul_den_iff_eq
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: simpa only [mk'_num_den] using mk'_eq_of_eq' (S := K) h
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : num A y * ↑(den A x) = num A x * ↑(den A y)
⊢ x = y
state_after: no goals

tactic: rw [h]
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : x = y
⊢ num A y * ↑(den A x) = num A x * ↑(den A y)
state_after: no goals
Theorem: ProjectiveSpectrum.zeroLocus_singleton_mul
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simpa using x.isPrime.mul_mem_iff_mem_or_mem
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
x : ProjectiveSpectrum 𝒜
⊢ x ∈ zeroLocus 𝒜 {f * g} ↔ x ∈ zeroLocus 𝒜 {f} ∪ zeroLocus 𝒜 {g}
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.map_zero
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: aesop_cat
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
⊢ map 0 Φ = 0
state_after: no goals
Theorem: complete_polishSpaceMetric
File: Mathlib/Topology/MetricSpace/Polish.lean

tactic: convert h.complete.choose_spec.2
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
ht : TopologicalSpace α
h : PolishSpace α
⊢ CompleteSpace α
state_after: case h.e'_2.h.e'_2.h.e'_2
α✝ : Type u_1
β : Type u_2
α : Type u_3
ht : TopologicalSpace α
h : PolishSpace α
⊢ polishSpaceMetric α = ⋯.choose

tactic: exact MetricSpace.replaceTopology_eq _ _
state_before: case h.e'_2.h.e'_2.h.e'_2
α✝ : Type u_1
β : Type u_2
α : Type u_3
ht : TopologicalSpace α
h : PolishSpace α
⊢ polishSpaceMetric α = ⋯.choose
state_after: no goals
Theorem: Polynomial.eval_eq_smeval
File: Mathlib/Algebra/Polynomial/Smeval.lean

tactic: rw [eval_eq_sum, smeval_eq_sum]
state_before: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ eval r p = p.smeval r
state_after: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ (p.sum fun e a => a * r ^ e) = p.sum (smul_pow r)

tactic: rfl
state_before: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ (p.sum fun e a => a * r ^ e) = p.sum (smul_pow r)
state_after: no goals
Theorem: WittVector.toPadicInt_comp_fromPadicInt_ext
File: Mathlib/RingTheory/WittVector/Compare.lean

tactic: rw [toPadicInt_comp_fromPadicInt]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
⊢ ((toPadicInt p).comp (fromPadicInt p)) x = (RingHom.id ℤ_[p]) x
state_after: no goals
Theorem: Finset.Ioo_subset_Ioo
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simpa [← coe_subset] using Set.Ioo_subset_Ioo ha hb
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁
hb : b₁ ≤ b₂
⊢ Ioo a₁ b₁ ⊆ Ioo a₂ b₂
state_after: no goals
Theorem: Computation.bind_promises
File: Mathlib/Data/Seq/Computation.lean

tactic: rcases exists_of_mem_bind bB with ⟨a', a's, ba'⟩
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ s.bind f
⊢ b = b'
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ s.bind f
a' : α
a's : a' ∈ s
ba' : b' ∈ f a'
⊢ b = b'

tactic: rw [← h1 a's] at ba'
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ s.bind f
a' : α
a's : a' ∈ s
ba' : b' ∈ f a'
⊢ b = b'
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ s.bind f
a' : α
a's : a' ∈ s
ba' : b' ∈ f a
⊢ b = b'

tactic: exact h2 ba'
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ s.bind f
a' : α
a's : a' ∈ s
ba' : b' ∈ f a
⊢ b = b'
state_after: no goals
Theorem: Real.cauchy_sub
File: Mathlib/Data/Real/Basic.lean

tactic: rw [sub_eq_add_neg, ← cauchy_neg, ← cauchy_add]
state_before: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = { cauchy := a }.cauchy - { cauchy := b }.cauchy
state_after: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = ({ cauchy := a } + -{ cauchy := b }).cauchy

tactic: rfl
state_before: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = ({ cauchy := a } + -{ cauchy := b }).cauchy
state_after: no goals