tasksource/leandojo huggingface dataset:
Theorem: codisjoint_inf_left
File: Mathlib/Order/Disjoint.lean

tactic: simp only [codisjoint_iff, sup_inf_right, inf_eq_top_iff]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderTop α
a b c : α
⊢ Codisjoint (a ⊓ b) c ↔ Codisjoint a c ∧ Codisjoint b c
Theorem: Submodule.mem_iSup
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [← span_singleton_le_iff_mem, le_iSup_iff]
state_before: R : Type u_2
R₂ : Type ?u.237748
K : Type ?u.237751
M : Type u_3
M₂ : Type ?u.237757
V : Type ?u.237760
S : Type ?u.237763
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p✝ p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
ι : Sort u_1
p : ι → Submodule R M
m : M
⊢ (m ∈ ⨆ (i : ι), p i) ↔ ∀ (N : Submodule R M), (∀ (i : ι), p i ≤ N) → m ∈ N

tactic: simp only [span_singleton_le_iff_mem]
state_before: R : Type u_2
R₂ : Type ?u.237748
K : Type ?u.237751
M : Type u_3
M₂ : Type ?u.237757
V : Type ?u.237760
S : Type ?u.237763
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p✝ p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
ι : Sort u_1
p : ι → Submodule R M
m : M
⊢ (∀ (b : Submodule R M), (∀ (i : ι), p i ≤ b) → span R {m} ≤ b) ↔ ∀ (N : Submodule R M), (∀ (i : ι), p i ≤ N) → m ∈ N
Theorem: Multiset.Ioc_eq_zero_iff
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ioc, Finset.val_eq_zero, Finset.Ioc_eq_empty_iff]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Ioc a b = 0 ↔ ¬a < b
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.triangle
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

tactic: dsimp [tensorHom]
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y : C
⊢ (BinaryFan.associatorOfLimitCone ℬ X 𝒯.cone.pt Y).hom ≫
      tensorHom ℬ (𝟙 X) (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt Y).isLimit).hom =
    tensorHom ℬ (BinaryFan.rightUnitor 𝒯.isLimit (ℬ X 𝒯.cone.pt).isLimit).hom (𝟙 Y)

tactic: apply IsLimit.hom_ext (ℬ _ _).isLimit
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y : C
⊢ (BinaryFan.associatorOfLimitCone ℬ X 𝒯.cone.pt Y).hom ≫
      IsLimit.lift (ℬ X Y).isLimit
        (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ 𝒯.cone.pt Y).cone.pt).cone ≫ 𝟙 X)
          (BinaryFan.snd (ℬ X (ℬ 𝒯.cone.pt Y).cone.pt).cone ≫ BinaryFan.snd (ℬ 𝒯.cone.pt Y).cone)) =
    IsLimit.lift (ℬ X Y).isLimit
      (BinaryFan.mk (BinaryFan.fst (ℬ (ℬ X 𝒯.cone.pt).cone.pt Y).cone ≫ BinaryFan.fst (ℬ X 𝒯.cone.pt).cone)
        (BinaryFan.snd (ℬ (ℬ X 𝒯.cone.pt).cone.pt Y).cone ≫ 𝟙 Y))

tactic: rintro ⟨⟨⟩⟩ <;> simp
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y : C
⊢ ∀ (j : Discrete WalkingPair),
    ((BinaryFan.associatorOfLimitCone ℬ X 𝒯.cone.pt Y).hom ≫
          IsLimit.lift (ℬ X Y).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ 𝒯.cone.pt Y).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ 𝒯.cone.pt Y).cone.pt).cone ≫ BinaryFan.snd (ℬ 𝒯.cone.pt Y).cone))) ≫
        (ℬ X Y).cone.π.app j =
      IsLimit.lift (ℬ X Y).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ (ℬ X 𝒯.cone.pt).cone.pt Y).cone ≫ BinaryFan.fst (ℬ X 𝒯.cone.pt).cone)
            (BinaryFan.snd (ℬ (ℬ X 𝒯.cone.pt).cone.pt Y).cone ≫ 𝟙 Y)) ≫
        (ℬ X Y).cone.π.app j
Theorem: Real.log_of_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [log_of_ne_zero hx.ne']
state_before: x y : ℝ
hx : 0 < x
⊢ log x = ↑(OrderIso.symm expOrderIso) { val := x, property := hx }

tactic: congr
state_before: x y : ℝ
hx : 0 < x
⊢ ↑(OrderIso.symm expOrderIso) { val := abs x, property := (_ : 0 < abs x) } =
    ↑(OrderIso.symm expOrderIso) { val := x, property := hx }

tactic: exact abs_of_pos hx
state_before: case h.e_6.h.e_val
x y : ℝ
hx : 0 < x
⊢ abs x = x
Theorem: RatFunc.mk_smul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: by_cases hq : q = 0
state_before: K : Type u
inst✝⁴ : CommRing K
R : Type u_1
inst✝³ : IsDomain K
inst✝² : Monoid R
inst✝¹ : DistribMulAction R K[X]
inst✝ : IsScalarTower R K[X] K[X]
c : R
p q : K[X]
⊢ RatFunc.mk (c • p) q = c • RatFunc.mk p q

tactic: rw [hq, mk_zero, mk_zero, ← ofFractionRing_smul, smul_zero]
state_before: case pos
K : Type u
inst✝⁴ : CommRing K
R : Type u_1
inst✝³ : IsDomain K
inst✝² : Monoid R
inst✝¹ : DistribMulAction R K[X]
inst✝ : IsScalarTower R K[X] K[X]
c : R
p q : K[X]
hq : q = 0
⊢ RatFunc.mk (c • p) q = c • RatFunc.mk p q

tactic: rw [mk_eq_localization_mk _ hq, mk_eq_localization_mk _ hq, ← Localization.smul_mk, ←
  ofFractionRing_smul]
state_before: case neg
K : Type u
inst✝⁴ : CommRing K
R : Type u_1
inst✝³ : IsDomain K
inst✝² : Monoid R
inst✝¹ : DistribMulAction R K[X]
inst✝ : IsScalarTower R K[X] K[X]
c : R
p q : K[X]
hq : ¬q = 0
⊢ RatFunc.mk (c • p) q = c • RatFunc.mk p q
Theorem: ite_and
File: Mathlib/Logic/Basic.lean

tactic: by_cases hp : P <;> by_cases hq : Q <;> simp [hp, hq]
state_before: α : Sort u_1
β : Sort ?u.40023
σ : α → Sort ?u.40019
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (if P ∧ Q then a else b) = if P then if Q then a else b else b
Theorem: MeasurableEquiv.map_map_symm
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [map_map e.measurable e.symm.measurable]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2284080
δ : Type ?u.2284083
ι : Type ?u.2284086
R : Type ?u.2284089
R' : Type ?u.2284092
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : MeasureTheory.Measure α
ν : MeasureTheory.Measure β
e : α ≃ᵐ β
⊢ Measure.map (↑e) (Measure.map (↑(symm e)) ν) = ν
Theorem: le_symmDiff_iff_left
File: Mathlib/Order/SymmDiff.lean

tactic: refine' ⟨fun h => _, fun h => h.symmDiff_eq_sup.symm ▸ le_sup_left⟩
state_before: ι : Type ?u.66703
α : Type u_1
β : Type ?u.66709
π : ι → Type ?u.66714
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ≤ a ∆ b ↔ Disjoint a b

tactic: rw [symmDiff_eq_sup_sdiff_inf] at h
state_before: ι : Type ?u.66703
α : Type u_1
β : Type ?u.66709
π : ι → Type ?u.66714
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
h : a ≤ a ∆ b
⊢ Disjoint a b

tactic: exact disjoint_iff_inf_le.mpr (le_sdiff_iff.1 <| inf_le_of_left_le h).le
state_before: ι : Type ?u.66703
α : Type u_1
β : Type ?u.66709
π : ι → Type ?u.66714
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
h : a ≤ (a ⊔ b) \ (a ⊓ b)
⊢ Disjoint a b
Theorem: List.aestronglyMeasurable_prod
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simpa only [← Pi.list_prod_apply] using l.aestronglyMeasurable_prod' hl
state_before: α : Type u_1
β : Type ?u.313618
γ : Type ?u.313621
ι : Type ?u.313624
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l : List (α → M)
hl : ∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (fun x => List.prod (List.map (fun f => f x) l)) μ
Theorem: FirstOrder.Language.BoundedFormula.realize_liftAt_one_self
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [realize_liftAt_one (refl n), iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.123113
P : Type ?u.123116
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
⊢ Realize (liftAt 1 n φ) v xs ↔ Realize φ v (xs ∘ ↑castSucc)

tactic: refine' congr rfl (congr rfl (funext fun i => _))
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.123113
P : Type ?u.123116
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
⊢ Realize φ v (xs ∘ fun i => if ↑i < n then ↑castSucc i else succ i) = Realize φ v (xs ∘ ↑castSucc)

tactic: rw [if_pos i.is_lt]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.123113
P : Type ?u.123116
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
i : Fin n
⊢ (if ↑i < n then ↑castSucc i else succ i) = ↑castSucc i
Theorem: MeasureTheory.integral_div_right_eq_self
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type ?u.43478
M : Type ?u.43481
α : Type ?u.43484
G : Type u_1
E : Type u_2
F : Type ?u.43493
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → E
g : G
⊢ (∫ (x : G), f (x / g) ∂μ) = ∫ (x : G), f x ∂μ

tactic: rw [integral_mul_right_eq_self f g⁻¹]
state_before: 𝕜 : Type ?u.43478
M : Type ?u.43481
α : Type ?u.43484
G : Type u_1
E : Type u_2
F : Type ?u.43493
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → E
g : G
⊢ (∫ (x : G), f (x * g⁻¹) ∂μ) = ∫ (x : G), f x ∂μ
Theorem: MvPolynomial.degrees_prod
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: refine' s.induction _ _
state_before: R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.39868
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s : Finset ι
f : ι → MvPolynomial σ R
⊢ degrees (∏ i in s, f i) ≤ ∑ i in s, degrees (f i)

tactic: simp only [Finset.prod_empty, Finset.sum_empty, degrees_one, le_refl]
state_before: case refine'_1
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.39868
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s : Finset ι
f : ι → MvPolynomial σ R
⊢ degrees (∏ i in ∅, f i) ≤ ∑ i in ∅, degrees (f i)

tactic: intro i s his ih
state_before: case refine'_2
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.39868
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s : Finset ι
f : ι → MvPolynomial σ R
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    ¬a ∈ s →
      degrees (∏ i in s, f i) ≤ ∑ i in s, degrees (f i) →
        degrees (∏ i in insert a s, f i) ≤ ∑ i in insert a s, degrees (f i)

tactic: rw [Finset.prod_insert his, Finset.sum_insert his]
state_before: case refine'_2
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.39868
r : R
e : ℕ
n m : σ
s✝¹ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s✝ : Finset ι
f : ι → MvPolynomial σ R
i : ι
s : Finset ι
his : ¬i ∈ s
ih : degrees (∏ i in s, f i) ≤ ∑ i in s, degrees (f i)
⊢ degrees (∏ i in insert i s, f i) ≤ ∑ i in insert i s, degrees (f i)

tactic: exact le_trans (degrees_mul _ _) (add_le_add_left ih _)
state_before: case refine'_2
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.39868
r : R
e : ℕ
n m : σ
s✝¹ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s✝ : Finset ι
f : ι → MvPolynomial σ R
i : ι
s : Finset ι
his : ¬i ∈ s
ih : degrees (∏ i in s, f i) ≤ ∑ i in s, degrees (f i)
⊢ degrees (f i * ∏ x in s, f x) ≤ degrees (f i) + ∑ x in s, degrees (f x)
Theorem: PrimeMultiset.prod_ofPNatList
File: Mathlib/Data/PNat/Factors.lean

tactic: have := prod_ofPNatMultiset (l : Multiset ℕ+) h
state_before: l : List ℕ+
h : ∀ (p : ℕ+), p ∈ l → PNat.Prime p
⊢ prod (ofPNatList l h) = List.prod l

tactic: rw [Multiset.coe_prod] at this
state_before: l : List ℕ+
h : ∀ (p : ℕ+), p ∈ l → PNat.Prime p
this : prod (ofPNatMultiset (↑l) h) = Multiset.prod ↑l
⊢ prod (ofPNatList l h) = List.prod l

tactic: exact this
state_before: l : List ℕ+
h : ∀ (p : ℕ+), p ∈ l → PNat.Prime p
this : prod (ofPNatMultiset (↑l) h) = List.prod l
⊢ prod (ofPNatList l h) = List.prod l
Theorem: CircleDeg1Lift.tendsto_translation_number'
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: exact_mod_cast (tendsto_add_atTop_iff_nat 1).2 (f.tendsto_translationNumber x)
state_before: f g : CircleDeg1Lift
x : ℝ
⊢ Tendsto (fun n => (↑(f ^ (n + 1)) x - x) / (↑n + 1)) atTop (𝓝 (τ f))
Theorem: symmDiff_hnot_self
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, hnot_symmDiff_self]
state_before: ι : Type ?u.56061
α : Type u_1
β : Type ?u.56067
π : ι → Type ?u.56072
inst✝ : CoheytingAlgebra α
a : α
⊢ a ∆ (￢a) = ⊤
Theorem: Ordnode.Valid'.node4L_lemma₁
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: linarith
state_before: α : Type ?u.278351
inst✝ : Preorder α
a b c d : ℕ
lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9
mr₂ : b + c + 1 ≤ 3 * d
mm₁ : b ≤ 3 * c
⊢ b < 3 * a + 1
Theorem: Complex.real_le_real
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [le_def, ofReal']
state_before: x y : ℝ
⊢ ↑x ≤ ↑y ↔ x ≤ y
Theorem: Real.arcsin_projIcc
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arcsin, Function.comp_apply, IccExtend_val, Function.comp_apply, IccExtend,
   Function.comp_apply]
state_before: x : ℝ
⊢ arcsin ↑(projIcc (-1) 1 (_ : -1 ≤ 1) x) = arcsin x
Theorem: Nat.le_mod_add_mod_of_dvd_add_of_not_dvd
File: Mathlib/Data/Nat/ModEq.lean

tactic: have : (a + b) % c = a % c + b % c := add_mod_of_add_mod_lt (lt_of_not_ge hc)
state_before: m n a✝ b✝ c✝ d a b c : ℕ
h : c ∣ a + b
ha : ¬c ∣ a
hc : ¬c ≤ a % c + b % c
⊢ False

tactic: simp_all [dvd_iff_mod_eq_zero]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
h : c ∣ a + b
ha : ¬c ∣ a
hc : ¬c ≤ a % c + b % c
this : (a + b) % c = a % c + b % c
⊢ False
Theorem: mem_span_finset
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rwa [Set.image_id]
state_before: R : Type u_2
M : Type u_1
N : Type ?u.761155
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
s : Finset M
x : M
hx : x ∈ span R ↑s
⊢ x ∈ span R (_root_.id '' ↑s)
Theorem: dite_not
File: Std/Logic.lean

tactic: by_cases h : P <;> simp [h]
state_before: α : Sort u_1
P : Prop
inst✝ : Decidable P
x : ¬P → α
y : ¬¬P → α
⊢ dite (¬P) x y = dite P (fun h => y (_ : ¬¬P)) x
Theorem: Int.even_xor'_odd'
File: Mathlib/Data/Int/Parity.lean

tactic: rcases even_or_odd n with (⟨k, rfl⟩ | ⟨k, rfl⟩) <;> use k
state_before: m n✝ n : ℤ
⊢ ∃ k, Xor' (n = 2 * k) (n = 2 * k + 1)

tactic: simpa only [← two_mul, Xor', true_and_iff, eq_self_iff_true, not_true, or_false_iff,
  and_false_iff] using (succ_ne_self (2 * k)).symm
state_before: case inl.intro
m n k : ℤ
⊢ Xor' (k + k = 2 * k) (k + k = 2 * k + 1)

tactic: simp only [Xor', add_right_eq_self, false_or_iff, eq_self_iff_true, not_true, not_false_iff,
  one_ne_zero, and_self_iff]
state_before: case inr.intro
m n k : ℤ
⊢ Xor' (2 * k + 1 = 2 * k) (2 * k + 1 = 2 * k + 1)
Theorem: OrderIso.preimage_Ici
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
⊢ ↑e ⁻¹' Ici b = Ici (↑(symm e) b)

tactic: simp [← e.le_iff_le]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
x : α
⊢ x ∈ ↑e ⁻¹' Ici b ↔ x ∈ Ici (↑(symm e) b)
Theorem: CategoryTheory.SemiadditiveOfBinaryBiproducts.isUnital_leftAdd
File: Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean

tactic: exact ⟨⟨fun f => by simp [hr f, leftAdd, Category.assoc, Category.comp_id, biprod.inr_desc]⟩,
  ⟨fun f => by simp [hl f, leftAdd, Category.assoc, Category.comp_id, biprod.inl_desc]⟩⟩
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
hl : ∀ (f : X ⟶ Y), biprod.lift f 0 = f ≫ biprod.inl
⊢ EckmannHilton.IsUnital (fun x x_1 => leftAdd X Y x x_1) 0

tactic: intro f
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr

tactic: ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
f : X ⟶ Y
⊢ biprod.lift 0 f = f ≫ biprod.inr

tactic: aesop_cat
state_before: case h₀
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
f : X ⟶ Y
⊢ biprod.lift 0 f ≫ biprod.fst = (f ≫ biprod.inr) ≫ biprod.fst

tactic: simp [biprod.lift_fst, Category.assoc, biprod.inr_fst, comp_zero]
state_before: case h₁
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
f : X ⟶ Y
⊢ biprod.lift 0 f ≫ biprod.snd = (f ≫ biprod.inr) ≫ biprod.snd

tactic: intro f
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
⊢ ∀ (f : X ⟶ Y), biprod.lift f 0 = f ≫ biprod.inl

tactic: ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
f : X ⟶ Y
⊢ biprod.lift f 0 = f ≫ biprod.inl

tactic: aesop_cat
state_before: case h₀
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
f : X ⟶ Y
⊢ biprod.lift f 0 ≫ biprod.fst = (f ≫ biprod.inl) ≫ biprod.fst

tactic: simp [biprod.lift_snd, Category.assoc, biprod.inl_snd, comp_zero]
state_before: case h₁
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
f : X ⟶ Y
⊢ biprod.lift f 0 ≫ biprod.snd = (f ≫ biprod.inl) ≫ biprod.snd

tactic: simp [hr f, leftAdd, Category.assoc, Category.comp_id, biprod.inr_desc]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
hl : ∀ (f : X ⟶ Y), biprod.lift f 0 = f ≫ biprod.inl
f : X ⟶ Y
⊢ leftAdd X Y 0 f = f

tactic: simp [hl f, leftAdd, Category.assoc, Category.comp_id, biprod.inl_desc]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
hr : ∀ (f : X ⟶ Y), biprod.lift 0 f = f ≫ biprod.inr
hl : ∀ (f : X ⟶ Y), biprod.lift f 0 = f ≫ biprod.inl
f : X ⟶ Y
⊢ leftAdd X Y f 0 = f
Theorem: Substring.Valid.next
File: Std/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h⟩ := h.validFor
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h : Valid x✝
e : (toString x✝).data = m₁ ++ c :: m₂
⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c }

tactic: simp [h.toString] at e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
e : (toString x✝).data = m₁ ++ c :: m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c }

tactic: subst e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ c :: m₂
⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c }

tactic: simp [h.next]
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
l r : List Char
h : ValidFor l (m₁ ++ c :: m₂) r x✝
⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c }
Theorem: CauSeq.lt_irrefl
File: Mathlib/Data/Real/CauSeq.lean

tactic: simp [zero_limZero]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f : CauSeq α abs
x✝ : f < f
h : f < f := x✝
⊢ LimZero (f - f)
Theorem: LiouvilleWith.nat_sub_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: simp [sub_eq_add_neg]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (↑n - x) ↔ LiouvilleWith p x
Theorem: MeasureTheory.AEEqFun.compMeasurable_toGerm
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.445345
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : BorelSpace β
inst✝⁴ : PseudoMetrizableSpace β
inst✝³ : PseudoMetrizableSpace γ
inst✝² : SecondCountableTopology γ
inst✝¹ : MeasurableSpace γ
inst✝ : OpensMeasurableSpace γ
g : β → γ
hg : Measurable g
f✝ : α →ₘ[μ] β
f : α → β
x✝ : AEStronglyMeasurable f μ
⊢ toGerm (compMeasurable g hg (mk f x✝)) = Germ.map g (toGerm (mk f x✝))
Theorem: affineSpan_singleton_union_vadd_eq_top_of_span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: convert ext_of_direction_eq _
    ⟨p, mem_affineSpan k (Set.mem_union_left _ (Set.mem_singleton _)), mem_top k V p⟩
state_before: k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.351531
s : Set V
p : P
h : Submodule.span k (range Subtype.val) = ⊤
⊢ affineSpan k ({p} ∪ (fun v => v +ᵥ p) '' s) = ⊤

tactic: rw [direction_affineSpan, direction_top,
  vectorSpan_eq_span_vsub_set_right k (Set.mem_union_left _ (Set.mem_singleton _) : p ∈ _),
  eq_top_iff, ← h]
state_before: case convert_1
k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.351531
s : Set V
p : P
h : Submodule.span k (range Subtype.val) = ⊤
⊢ direction (affineSpan k ({p} ∪ (fun v => v +ᵥ p) '' s)) = direction ⊤

tactic: apply Submodule.span_mono
state_before: case convert_1
k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.351531
s : Set V
p : P
h : Submodule.span k (range Subtype.val) = ⊤
⊢ Submodule.span k (range Subtype.val) ≤ Submodule.span k ((fun x => x -ᵥ p) '' ({p} ∪ (fun v => v +ᵥ p) '' s))

tactic: rintro v ⟨v', rfl⟩
state_before: case convert_1.h
k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.351531
s : Set V
p : P
h : Submodule.span k (range Subtype.val) = ⊤
⊢ range Subtype.val ⊆ (fun x => x -ᵥ p) '' ({p} ∪ (fun v => v +ᵥ p) '' s)

tactic: use (v' : V) +ᵥ p
state_before: case convert_1.h.intro
k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.351531
s : Set V
p : P
h : Submodule.span k (range Subtype.val) = ⊤
v' : { x // x ∈ s }
⊢ ↑v' ∈ (fun x => x -ᵥ p) '' ({p} ∪ (fun v => v +ᵥ p) '' s)

tactic: simp
state_before: case convert_1.h.intro
k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.351531
s : Set V
p : P
h : Submodule.span k (range Subtype.val) = ⊤
v' : { x // x ∈ s }
⊢ ↑v' +ᵥ p ∈ {p} ∪ (fun v => v +ᵥ p) '' s ∧ (fun x => x -ᵥ p) (↑v' +ᵥ p) = ↑v'
Theorem: List.get?_modifyNth_eq
File: Std/Data/List/Lemmas.lean

tactic: simp only [get?_modifyNth, if_pos]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
⊢ get? (modifyNth f n l) n = f <$> get? l n
Theorem: RatFunc.liftOn_ofFractionRing_mk
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [RatFunc.liftOn]
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : { x // x ∈ K[X]⁰ }
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ RatFunc.liftOn { toFractionRing := Localization.mk n d } f H = f n ↑d

tactic: exact Localization.liftOn_mk _ _ _ _
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : { x // x ∈ K[X]⁰ }
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ Localization.liftOn { toFractionRing := Localization.mk n d }.toFractionRing (fun p q => f p ↑q)
      (_ : ∀ {p p' : K[X]} {q q' : { x // x ∈ K[X]⁰ }}, ↑(Localization.r K[X]⁰) (p, q) (p', q') → f p ↑q = f p' ↑q') =
    f n ↑d