1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ProbabilityTheory.IndepFun.mgf_add
File: Mathlib/Probability/Moments.lean

tactic: simp_rw [mgf, Pi.add_apply, mul_add, exp_add]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
hX : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
hY : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ mgf (X + Y) μ t = mgf X μ t * mgf Y μ t
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
hX : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
hY : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ ∫ (x : Ω), rexp (t * X x) * rexp (t * Y x) ∂μ = (∫ (x : Ω), rexp (t * X x) ∂μ) * ∫ (x : Ω), rexp (t * Y x) ∂μ

tactic: exact (h_indep.exp_mul t t).integral_mul hX hY
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
hX : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
hY : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ ∫ (x : Ω), rexp (t * X x) * rexp (t * Y x) ∂μ = (∫ (x : Ω), rexp (t * X x) ∂μ) * ∫ (x : Ω), rexp (t * Y x) ∂μ
state_after: no goals
Theorem: YoungDiagram.transpose_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: ext x
state_before: μ : YoungDiagram
⊢ μ.transpose.transpose = μ
state_after: case cells.a
μ : YoungDiagram
x : ℕ × ℕ
⊢ x ∈ μ.transpose.transpose.cells ↔ x ∈ μ.cells

tactic: simp
state_before: case cells.a
μ : YoungDiagram
x : ℕ × ℕ
⊢ x ∈ μ.transpose.transpose.cells ↔ x ∈ μ.cells
state_after: no goals
Theorem: CategoryTheory.Bicategory.whiskerLeft_iff
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η θ : f ⟶ g
⊢ 𝟙 a ◁ η = 𝟙 a ◁ θ ↔ η = θ
state_after: no goals
Theorem: DoubleQuot.ker_quotQuotMk
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rw [RingHom.ker_eq_comap_bot, quotQuotMk, ← comap_comap, ← RingHom.ker, mk_ker,
  comap_map_of_surjective (Ideal.Quotient.mk I) Quotient.mk_surjective, ← RingHom.ker, mk_ker,
  sup_comm]
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
⊢ RingHom.ker (quotQuotMk I J) = I ⊔ J
state_after: no goals
Theorem: Order.pred_eq_iSup
File: Mathlib/Order/SuccPred/Basic.lean

tactic: refine le_antisymm ?_ (iSup_le fun b => iSup_le le_pred_of_lt)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
⊢ pred a = ⨆ b, ⨆ (_ : b < a), b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b

tactic: obtain rfl | ha := eq_or_ne a ⊥
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
⊢ pred ⊥ ≤ ⨆ b, ⨆ (_ : b < ⊥), b

case inr
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
ha : a ≠ ⊥
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b

tactic: rw [pred_bot]
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
⊢ pred ⊥ ≤ ⨆ b, ⨆ (_ : b < ⊥), b
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
⊢ ⊥ ≤ ⨆ b, ⨆ (_ : b < ⊥), b

tactic: exact bot_le
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
⊢ ⊥ ≤ ⨆ b, ⨆ (_ : b < ⊥), b
state_after: no goals

tactic: exact @le_iSup₂ _ _ (fun b => b < a) _ (fun a _ => a) (pred a) (pred_lt_iff_ne_bot.2 ha)
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : PredOrder α
a : α
ha : a ≠ ⊥
⊢ pred a ≤ ⨆ b, ⨆ (_ : b < a), b
state_after: no goals
Theorem: Nat.dist_comm
File: Mathlib/Data/Nat/Dist.lean

tactic: simp [dist, add_comm]
state_before: n m : ℕ
⊢ n.dist m = m.dist n
state_after: no goals
Theorem: Primrec.nat_findGreatest
File: Mathlib/Computability/Primrec.lean

tactic: induction f x <;> simp [Nat.findGreatest, *]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
f : α → ℕ
p : α → ℕ → Prop
inst✝ : (x : α) → (n : ℕ) → Decidable (p x n)
hf : Primrec f
hp : PrimrecRel p
x : α
⊢ Nat.rec 0 (fun n IH => if p x ((n, IH).1 + 1) then (n, IH).1 + 1 else (n, IH).2) (f x) = Nat.findGreatest (p x) (f x)
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.diagonal_isStableUnderComposition
File: Mathlib/CategoryTheory/MorphismProperty/Limits.lean

tactic: rw [diagonal_iff, pullback.diagonal_comp]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
inst✝ : P.IsStableUnderComposition
hP' : P.RespectsIso
hP'' : P.StableUnderBaseChange
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
h₁ : P.diagonal x✝¹
h₂ : P.diagonal x✝
⊢ P.diagonal (x✝¹ ≫ x✝)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
inst✝ : P.IsStableUnderComposition
hP' : P.RespectsIso
hP'' : P.StableUnderBaseChange
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
h₁ : P.diagonal x✝¹
h₂ : P.diagonal x✝
⊢ P (pullback.diagonal x✝¹ ≫ (pullbackDiagonalMapIdIso x✝¹ x✝¹ x✝).inv ≫ pullback.snd)

tactic: exact P.comp_mem _ _ h₁ (by simpa [hP'.cancel_left_isIso] using hP''.snd _ _ h₂)
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
inst✝ : P.IsStableUnderComposition
hP' : P.RespectsIso
hP'' : P.StableUnderBaseChange
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
h₁ : P.diagonal x✝¹
h₂ : P.diagonal x✝
⊢ P (pullback.diagonal x✝¹ ≫ (pullbackDiagonalMapIdIso x✝¹ x✝¹ x✝).inv ≫ pullback.snd)
state_after: no goals

tactic: simpa [hP'.cancel_left_isIso] using hP''.snd _ _ h₂
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
inst✝ : P.IsStableUnderComposition
hP' : P.RespectsIso
hP'' : P.StableUnderBaseChange
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
h₁ : P.diagonal x✝¹
h₂ : P.diagonal x✝
⊢ P ((pullbackDiagonalMapIdIso x✝¹ x✝¹ x✝).inv ≫ pullback.snd)
state_after: no goals
Theorem: schnirelmannDensity_insert_zero
File: Mathlib/Combinatorics/Schnirelmann.lean

tactic: aesop
state_before: A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
inst✝ : DecidablePred fun x => x ∈ insert 0 A
⊢ ∀ n > 0, n ∈ insert 0 A ↔ n ∈ A
state_after: no goals
Theorem: Finset.supIndep_univ_bool
File: Mathlib/Order/SupIndep.lean

tactic: simp only [Ne, not_false_iff]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f✝ : ι → α
i : ι
f : Bool → α
⊢ true ≠ false
state_after: no goals
Theorem: SimplexCategory.epi_iff_surjective
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: rw [← Functor.epi_map_iff_epi skeletalEquivalence.functor]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Epi f ↔ Function.Surjective ⇑(Hom.toOrderHom f)
state_after: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalEquivalence.functor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)

tactic: dsimp only [skeletalEquivalence, Functor.asEquivalence_functor]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalEquivalence.functor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)
state_after: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalFunctor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)

tactic: simp only [skeletalFunctor_obj, skeletalFunctor_map,
  NonemptyFinLinOrd.epi_iff_surjective, NonemptyFinLinOrd.coe_of]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalFunctor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)
state_after: no goals
Theorem: irrational_div_rat_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [div_eq_mul_inv, ← cast_inv, irrational_mul_rat_iff, Ne, inv_eq_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x / ↑q) ↔ q ≠ 0 ∧ Irrational x
state_after: no goals
Theorem: Finset.prod_subtype
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: subst p
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
p : α → Prop
F : Fintype (Subtype p)
s : Finset α
h : ∀ (x : α), x ∈ s ↔ p x
f : α → β
this : (fun x => x ∈ s) = p
⊢ ∏ a ∈ s, f a = ∏ a : Subtype p, f ↑a
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
F : Fintype { x // x ∈ s }
h : ∀ (x : α), x ∈ s ↔ (fun x => x ∈ s) x
⊢ ∏ a ∈ s, f a = ∏ a : { x // x ∈ s }, f ↑a

tactic: rw [← prod_coe_sort]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
F : Fintype { x // x ∈ s }
h : ∀ (x : α), x ∈ s ↔ (fun x => x ∈ s) x
⊢ ∏ a ∈ s, f a = ∏ a : { x // x ∈ s }, f ↑a
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
F : Fintype { x // x ∈ s }
h : ∀ (x : α), x ∈ s ↔ (fun x => x ∈ s) x
⊢ ∏ i : { x // x ∈ s }, f ↑i = ∏ a : { x // x ∈ s }, f ↑a

tactic: congr!
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
F : Fintype { x // x ∈ s }
h : ∀ (x : α), x ∈ s ↔ (fun x => x ∈ s) x
⊢ ∏ i : { x // x ∈ s }, f ↑i = ∏ a : { x // x ∈ s }, f ↑a
state_after: no goals
Theorem: ProbabilityTheory.measure_eq_zero_or_one_or_top_of_indepSet_self
File: Mathlib/Probability/Independence/ZeroOne.lean

tactic: simpa only [ae_dirac_eq, Filter.eventually_pure]
  using kernel.measure_eq_zero_or_one_or_top_of_indepSet_self h_indep
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μα : Measure α
μ : Measure Ω
t : Set Ω
h_indep : IndepSet t t μ
⊢ μ t = 0 ∨ μ t = 1 ∨ μ t = ⊤
state_after: no goals
Theorem: MvQPF.Cofix.bisim₂
File: Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean

tactic: intros
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
⊢ ∀ (x y : Cofix F α), r x y → LiftR (fun {i} => α.RelLast r) x.dest y.dest
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
x✝ y✝ : Cofix F α
a✝ : r x✝ y✝
⊢ LiftR (fun {i} => α.RelLast r) x✝.dest y✝.dest

tactic: rw [← LiftR_RelLast_iff]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
x✝ y✝ : Cofix F α
a✝ : r x✝ y✝
⊢ LiftR (fun {i} => α.RelLast r) x✝.dest y✝.dest
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
x✝ y✝ : Cofix F α
a✝ : r x✝ y✝
⊢ LiftR' (α.RelLast' r) x✝.dest y✝.dest

tactic: apply h
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
x✝ y✝ : Cofix F α
a✝ : r x✝ y✝
⊢ LiftR' (α.RelLast' r) x✝.dest y✝.dest
state_after: case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
x✝ y✝ : Cofix F α
a✝ : r x✝ y✝
⊢ r x✝ y✝

tactic: assumption
state_before: case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
r : Cofix F α → Cofix F α → Prop
h : ∀ (x y : Cofix F α), r x y → LiftR' (α.RelLast' r) x.dest y.dest
x✝ y✝ : Cofix F α
a✝ : r x✝ y✝
⊢ r x✝ y✝
state_after: no goals
Theorem: List.eraseP_sublist
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: match exists_or_eq_self_of_eraseP p l with
| .inl h => rw [h]; apply Sublist.refl
| .inr ⟨c, l₁, l₂, _, _, h₃, h₄⟩ => rw [h₄, h₃]; simp
state_before: α : Type u_1
p : α → Bool
l : List α
⊢ eraseP p l <+ l
state_after: no goals

tactic: rw [h]
state_before: α : Type u_1
p : α → Bool
l : List α
h : eraseP p l = l
⊢ eraseP p l <+ l
state_after: α : Type u_1
p : α → Bool
l : List α
h : eraseP p l = l
⊢ l <+ l

tactic: apply Sublist.refl
state_before: α : Type u_1
p : α → Bool
l : List α
h : eraseP p l = l
⊢ l <+ l
state_after: no goals

tactic: rw [h₄, h₃]
state_before: α : Type u_1
p : α → Bool
l : List α
c : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ eraseP p l <+ l
state_after: α : Type u_1
p : α → Bool
l : List α
c : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ l₁ ++ l₂ <+ l₁ ++ c :: l₂

tactic: simp
state_before: α : Type u_1
p : α → Bool
l : List α
c : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ l₁ ++ l₂ <+ l₁ ++ c :: l₂
state_after: no goals
Theorem: CategoryTheory.Abelian.exact_iff_image_eq_kernel
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: constructor
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g ↔ imageSubobject f = kernelSubobject g
state_after: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g → imageSubobject f = kernelSubobject g

case mpr
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ imageSubobject f = kernelSubobject g → Exact f g

tactic: intro h
state_before: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g → imageSubobject f = kernelSubobject g
state_after: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ imageSubobject f = kernelSubobject g

tactic: have : IsIso (imageToKernel f g h.w) := have := h.epi; isIso_of_mono_of_epi _
state_before: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ imageSubobject f = kernelSubobject g
state_after: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
this : IsIso (imageToKernel f g ⋯)
⊢ imageSubobject f = kernelSubobject g

tactic: refine Subobject.eq_of_comm (asIso (imageToKernel _ _ h.w)) ?_
state_before: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
this : IsIso (imageToKernel f g ⋯)
⊢ imageSubobject f = kernelSubobject g
state_after: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
this : IsIso (imageToKernel f g ⋯)
⊢ (asIso (imageToKernel f g ⋯)).hom ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow

tactic: simp
state_before: case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
this : IsIso (imageToKernel f g ⋯)
⊢ (asIso (imageToKernel f g ⋯)).hom ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow
state_after: no goals

tactic: apply exact_of_image_eq_kernel
state_before: case mpr
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ imageSubobject f = kernelSubobject g → Exact f g
state_after: no goals
Theorem: Set.preimage_const_add_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp only [← Icc_min_max, preimage_const_add_Icc, min_sub_sub_right, max_sub_sub_right]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => a + x) ⁻¹' [[b, c]] = [[b - a, c - a]]
state_after: no goals
Theorem: LinearMap.coprod_inr
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
⊢ f.coprod g ∘ₗ inr R M M₂ = g
state_after: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
x✝ : M₂
⊢ (f.coprod g ∘ₗ inr R M M₂) x✝ = g x✝

tactic: simp only [map_zero, coprod_apply, inr_apply, zero_add, comp_apply]
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
x✝ : M₂
⊢ (f.coprod g ∘ₗ inr R M M₂) x✝ = g x✝
state_after: no goals
Theorem: StrictConvexSpace.of_norm_add_ne_two
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: refine
  StrictConvexSpace.of_norm_combo_ne_one fun x y hx hy hne =>
    ⟨1 / 2, 1 / 2, one_half_pos.le, one_half_pos.le, add_halves _, ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
⊢ StrictConvexSpace ℝ E
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ‖(1 / 2) • x + (1 / 2) • y‖ ≠ 1

tactic: rw [← smul_add, norm_smul, Real.norm_of_nonneg one_half_pos.le, one_div, ← div_eq_inv_mul, Ne,
  div_eq_one_iff_eq (two_ne_zero' ℝ)]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ‖(1 / 2) • x + (1 / 2) • y‖ ≠ 1
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ¬‖x + y‖ = 2

tactic: exact h hx hy hne
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ¬‖x + y‖ = 2
state_after: no goals
Theorem: Multiset.union_le
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← eq_union_left h₂]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
h₁ : s ≤ u
h₂ : t ≤ u
⊢ s ∪ t ≤ u
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
h₁ : s ≤ u
h₂ : t ≤ u
⊢ s ∪ t ≤ u ∪ t

tactic: exact union_le_union_right h₁ t
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
h₁ : s ≤ u
h₂ : t ≤ u
⊢ s ∪ t ≤ u ∪ t
state_after: no goals
Theorem: Equiv.Perm.signBijAux_surj
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: dsimp [signBijAux]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : f⁻¹ a₂ < f⁻¹ a₁
⊢ f.signBijAux ⟨f⁻¹ a₁, f⁻¹ a₂⟩ = ⟨a₁, a₂⟩
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : f⁻¹ a₂ < f⁻¹ a₁
⊢ (if f (f⁻¹ a₂) < f (f⁻¹ a₁) then ⟨f (f⁻¹ a₁), f (f⁻¹ a₂)⟩ else ⟨f (f⁻¹ a₂), f (f⁻¹ a₁)⟩) = ⟨a₁, a₂⟩

tactic: rw [apply_inv_self, apply_inv_self, if_pos (mem_finPairsLT.1 ha)]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : f⁻¹ a₂ < f⁻¹ a₁
⊢ (if f (f⁻¹ a₂) < f (f⁻¹ a₁) then ⟨f (f⁻¹ a₁), f (f⁻¹ a₂)⟩ else ⟨f (f⁻¹ a₂), f (f⁻¹ a₁)⟩) = ⟨a₁, a₂⟩
state_after: no goals

tactic: simp [mem_finPairsLT, f⁻¹.injective h, lt_irrefl] at ha
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
h : f⁻¹ a₁ = f⁻¹ a₂
⊢ False
state_after: no goals

tactic: dsimp [signBijAux]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
⊢ f.signBijAux ⟨f⁻¹ a₂, f⁻¹ a₁⟩ = ⟨a₁, a₂⟩
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
⊢ (if f (f⁻¹ a₁) < f (f⁻¹ a₂) then ⟨f (f⁻¹ a₂), f (f⁻¹ a₁)⟩ else ⟨f (f⁻¹ a₁), f (f⁻¹ a₂)⟩) = ⟨a₁, a₂⟩

tactic: rw [apply_inv_self, apply_inv_self, if_neg (mem_finPairsLT.1 ha).le.not_lt]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : ⟨a₁, a₂⟩ ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
⊢ (if f (f⁻¹ a₁) < f (f⁻¹ a₂) then ⟨f (f⁻¹ a₂), f (f⁻¹ a₁)⟩ else ⟨f (f⁻¹ a₁), f (f⁻¹ a₂)⟩) = ⟨a₁, a₂⟩
state_after: no goals