tasksource/leandojo huggingface dataset:
Theorem: Algebra.TensorProduct.productMap_right
File: Mathlib/RingTheory/TensorProduct.lean

tactic: simp
state_before: R : Type u_3
A : Type u_4
B : Type u_1
S : Type u_2
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
⊢ ∀ (x : B), ↑(AlgHom.comp (productMap f g) includeRight) x = ↑g x
Theorem: Nat.Linear.Expr.eq_of_toNormPoly
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp [toNormPoly, Poly.norm] at h
state_before: ctx : Context
a b : Expr
h : toNormPoly a = toNormPoly b
⊢ denote ctx a = denote ctx b

tactic: have h := congrArg (Poly.denote ctx) h
state_before: ctx : Context
a b : Expr
h : Poly.fuse (Poly.sort.go (toPoly a) []) = Poly.fuse (Poly.sort.go (toPoly b) [])
⊢ denote ctx a = denote ctx b

tactic: simp at h
state_before: ctx : Context
a b : Expr
h✝ : Poly.fuse (Poly.sort.go (toPoly a) []) = Poly.fuse (Poly.sort.go (toPoly b) [])
h : Poly.denote ctx (Poly.fuse (Poly.sort.go (toPoly a) [])) = Poly.denote ctx (Poly.fuse (Poly.sort.go (toPoly b) []))
⊢ denote ctx a = denote ctx b

tactic: assumption
state_before: ctx : Context
a b : Expr
h✝ : Poly.fuse (Poly.sort.go (toPoly a) []) = Poly.fuse (Poly.sort.go (toPoly b) [])
h : denote ctx a = denote ctx b
⊢ denote ctx a = denote ctx b
Theorem: Submodule.IsOrtho.comap
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: rw [isOrtho_iff_inner_eq] at *
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 F
h : U ⟂ V
⊢ Submodule.comap f U ⟂ Submodule.comap f V

tactic: simp_rw [mem_comap, ← f.inner_map_map]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 F
h : ∀ (u : F), u ∈ U → ∀ (v : F), v ∈ V → inner u v = 0
⊢ ∀ (u : E), u ∈ Submodule.comap f U → ∀ (v : E), v ∈ Submodule.comap f V → inner u v = 0

tactic: intro u hu v hv
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 F
h : ∀ (u : F), u ∈ U → ∀ (v : F), v ∈ V → inner u v = 0
⊢ ∀ (u : E), ↑f u ∈ U → ∀ (v : E), ↑f v ∈ V → inner (↑f u) (↑f v) = 0

tactic: exact h _ hu _ hv
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
f : E →ₗᵢ[𝕜] F
U V : Submodule 𝕜 F
h : ∀ (u : F), u ∈ U → ∀ (v : F), v ∈ V → inner u v = 0
u : E
hu : ↑f u ∈ U
v : E
hv : ↑f v ∈ V
⊢ inner (↑f u) (↑f v) = 0
Theorem: Set.iUnion_Ico_left
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp only [← Ici_inter_Iio, ← iUnion_inter, iUnion_Ici, univ_inter]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a b✝ c b : α
⊢ (⋃ (a : α), Ico a b) = Iio b
Theorem: Encodable.decode_ge_two
File: Mathlib/Logic/Encodable/Basic.lean

tactic: suffices decodeSum n = none by
  change (decodeSum n).bind _ = none
  rw [this]
  rfl
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
⊢ decode n = none

tactic: have : 1 ≤ n / 2 := by
  rw [Nat.le_div_iff_mul_le]
  exacts [h, by decide]
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
⊢ decodeSum n = none

tactic: cases' exists_eq_succ_of_ne_zero (_root_.ne_of_gt this) with m e
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
this : 1 ≤ n / 2
⊢ decodeSum n = none

tactic: simp [decodeSum, div2_val]
state_before: case intro
α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
this : 1 ≤ n / 2
m : ℕ
e : n / 2 = succ m
⊢ decodeSum n = none

tactic: cases bodd n <;> simp [e]
state_before: case intro
α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
this : 1 ≤ n / 2
m : ℕ
e : n / 2 = succ m
⊢ (match (bodd n, n / 2) with
    | (false, m) => Option.map Sum.inl (decode m)
    | (fst, m) => Option.map Sum.inr (decode m)) =
    none

tactic: change (decodeSum n).bind _ = none
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
this : decodeSum n = none
⊢ decode n = none

tactic: rw [this]
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
this : decodeSum n = none
⊢ Option.bind (decodeSum n) (some ∘ ↑Equiv.boolEquivPUnitSumPUnit.symm) = none

tactic: rfl
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
this : decodeSum n = none
⊢ Option.bind none (some ∘ ↑Equiv.boolEquivPUnitSumPUnit.symm) = none

tactic: rw [Nat.le_div_iff_mul_le]
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
⊢ 1 ≤ n / 2

tactic: exacts [h, by decide]
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
⊢ 1 * 2 ≤ n

α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
⊢ 0 < 2

tactic: decide
state_before: α : Type ?u.18106
β : Type ?u.18109
n : ℕ
h : 2 ≤ n
⊢ 0 < 2
Theorem: finprod_mem_sUnion
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [Set.sUnion_eq_biUnion]
state_before: α : Type u_1
β : Type ?u.370021
ι : Type ?u.370024
G : Type ?u.370027
M : Type u_2
N : Type ?u.370033
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : PairwiseDisjoint t id
ht₀ : Set.Finite t
ht₁ : ∀ (x : Set α), x ∈ t → Set.Finite x
⊢ (∏ᶠ (a : α) (_ : a ∈ ⋃₀ t), f a) = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a

tactic: exact finprod_mem_biUnion h ht₀ ht₁
state_before: α : Type u_1
β : Type ?u.370021
ι : Type ?u.370024
G : Type ?u.370027
M : Type u_2
N : Type ?u.370033
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : PairwiseDisjoint t id
ht₀ : Set.Finite t
ht₁ : ∀ (x : Set α), x ∈ t → Set.Finite x
⊢ (∏ᶠ (a : α) (_ : a ∈ ⋃ (i : Set α) (_ : i ∈ t), i), f a) = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
Theorem: Filter.iInf_principal_finset
File: Mathlib/Order/Filter/Basic.lean

tactic: induction' s using Finset.induction_on with i s _ hs
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.120715
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
s : Finset ι
f : ι → Set α
⊢ (⨅ (i : ι) (_ : i ∈ s), 𝓟 (f i)) = 𝓟 (⋂ (i : ι) (_ : i ∈ s), f i)

tactic: simp
state_before: case empty
α : Type u
β : Type v
γ : Type w
δ : Type ?u.120715
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type w
f : ι → Set α
⊢ (⨅ (i : ι) (_ : i ∈ ∅), 𝓟 (f i)) = 𝓟 (⋂ (i : ι) (_ : i ∈ ∅), f i)

tactic: rw [Finset.iInf_insert, Finset.set_biInter_insert, hs, inf_principal]
state_before: case insert
α : Type u
β : Type v
γ : Type w
δ : Type ?u.120715
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
f : ι → Set α
i : ι
s : Finset ι
a✝ : ¬i ∈ s
hs : (⨅ (i : ι) (_ : i ∈ s), 𝓟 (f i)) = 𝓟 (⋂ (i : ι) (_ : i ∈ s), f i)
⊢ (⨅ (i_1 : ι) (_ : i_1 ∈ insert i s), 𝓟 (f i_1)) = 𝓟 (⋂ (i_1 : ι) (_ : i_1 ∈ insert i s), f i_1)
Theorem: CategoryTheory.GrothendieckTopology.plusMap_plusLift
File: Mathlib/CategoryTheory/Sites/Plus.lean

tactic: apply J.plusLift_unique
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ plusMap J η ≫ plusLift J γ hR = plusLift J (η ≫ γ) hR

tactic: rw [← Category.assoc, ← J.toPlus_naturality, Category.assoc, J.toPlus_plusLift]
state_before: case hγ
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toPlus J P ≫ plusMap J η ≫ plusLift J γ hR = η ≫ γ
Theorem: SimpleGraph.Walk.cons_isTrail_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [isTrail_def, and_comm]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
h : Adj G u v
p : Walk G v w
⊢ IsTrail (cons h p) ↔ IsTrail p ∧ ¬Quotient.mk (Sym2.Rel.setoid V) (u, v) ∈ edges p
Theorem: Polynomial.monic_mul_C_of_leadingCoeff_mul_eq_one
File: Mathlib/Data/Polynomial/Monic.lean

tactic: unfold Monic
state_before: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : leadingCoeff p * b = 1
⊢ Monic (p * ↑C b)

tactic: nontriviality
state_before: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : leadingCoeff p * b = 1
⊢ leadingCoeff (p * ↑C b) = 1

tactic: rw [leadingCoeff_mul' _] <;> simp [leadingCoeff_C b, hp]
state_before: R : Type u
S : Type v
a b✝ : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
b : R
hp : leadingCoeff p * b = 1
✝ : Nontrivial R
⊢ leadingCoeff (p * ↑C b) = 1
Theorem: ZMod.val_coe_unit_coprime
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: n : ℕ
u : (ZMod n)ˣ
⊢ Nat.coprime (val ↑u) n

tactic: apply Nat.coprime_of_mul_modEq_one ((u⁻¹ : Units (ZMod (n + 1))) : ZMod (n + 1)).val
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
⊢ Nat.coprime (val ↑u) (Nat.succ n)

tactic: have := Units.ext_iff.1 (mul_right_inv u)
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
⊢ val ↑u * val ↑u⁻¹ ≡ 1 [MOD Nat.succ n]

tactic: rw [Units.val_one] at this
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
this : ↑(u * u⁻¹) = ↑1
⊢ val ↑u * val ↑u⁻¹ ≡ 1 [MOD Nat.succ n]

tactic: rw [← eq_iff_modEq_nat, Nat.cast_one, ← this]
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
this : ↑(u * u⁻¹) = 1
⊢ val ↑u * val ↑u⁻¹ ≡ 1 [MOD Nat.succ n]

tactic: clear this
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
this : ↑(u * u⁻¹) = 1
⊢ ↑(val ↑u * val ↑u⁻¹) = ↑(u * u⁻¹)

tactic: rw [← nat_cast_zmod_val ((u * u⁻¹ : Units (ZMod (n + 1))) : ZMod (n + 1))]
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
⊢ ↑(val ↑u * val ↑u⁻¹) = ↑(u * u⁻¹)

tactic: rw [Units.val_mul, val_mul, nat_cast_mod]
state_before: case succ
n : ℕ
u : (ZMod (Nat.succ n))ˣ
⊢ ↑(val ↑u * val ↑u⁻¹) = ↑(val ↑(u * u⁻¹))

tactic: rcases Int.units_eq_one_or u with (rfl | rfl) <;> simp
state_before: case zero
u : (ZMod Nat.zero)ˣ
⊢ Nat.coprime (val ↑u) Nat.zero
Theorem: CauSeq.mul_equiv_zero'
File: Mathlib/Data/Real/CauSeq.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this : LimZero (f - 0)
⊢ LimZero f

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this✝ : LimZero (f - 0)
this : LimZero (f * g)
⊢ LimZero (f * g - 0)
Theorem: Real.sqrt_mul'
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [mul_comm, sqrt_mul hy, mul_comm]
state_before: x y : ℝ
hy : 0 ≤ y
⊢ sqrt (x * y) = sqrt x * sqrt y
Theorem: Polynomial.scaleRoots_eval₂_eq_zero_of_eval₂_div_eq_zero
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: convert @scaleRoots_eval₂_eq_zero _ _ _ _ p f _ s hr
state_before: A : Type u_1
K : Type u_2
R : Type ?u.324057
S : Type ?u.324060
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : A[X]
f : A →+* K
hf : Function.Injective ↑f
r s : A
hr : eval₂ f (↑f r / ↑f s) p = 0
hs : s ∈ nonZeroDivisors A
⊢ eval₂ f (↑f r) (scaleRoots p s) = 0

tactic: rw [← mul_div_assoc, mul_comm, mul_div_cancel]
state_before: case h.e'_2.h.e'_6
A : Type u_1
K : Type u_2
R : Type ?u.324057
S : Type ?u.324060
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : A[X]
f : A →+* K
hf : Function.Injective ↑f
r s : A
hr : eval₂ f (↑f r / ↑f s) p = 0
hs : s ∈ nonZeroDivisors A
⊢ ↑f r = ↑f s * (↑f r / ↑f s)

tactic: exact map_ne_zero_of_mem_nonZeroDivisors _ hf hs
state_before: case h.e'_2.h.e'_6.h
A : Type u_1
K : Type u_2
R : Type ?u.324057
S : Type ?u.324060
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : A[X]
f : A →+* K
hf : Function.Injective ↑f
r s : A
hr : eval₂ f (↑f r / ↑f s) p = 0
hs : s ∈ nonZeroDivisors A
⊢ ↑f s ≠ 0
Theorem: Commute.exp_right
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: rw [exp_eq_tsum]
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : TopologicalSpace 𝔸
inst✝¹ : TopologicalRing 𝔸
inst✝ : T2Space 𝔸
x y : 𝔸
h : Commute x y
⊢ Commute x (exp 𝕂 y)

tactic: exact Commute.tsum_right x fun n => (h.pow_right n).smul_right _
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : TopologicalSpace 𝔸
inst✝¹ : TopologicalRing 𝔸
inst✝ : T2Space 𝔸
x y : 𝔸
h : Commute x y
⊢ Commute x ((fun x => ∑' (n : ℕ), (↑n !)⁻¹ • x ^ n) y)
Theorem: toIcoDiv_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [add_smul, add_sub_add_right_eq_sub] using sub_toIcoDiv_zsmul_mem_Ico hp a b
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b + m • p - (toIcoDiv hp a b + m) • p ∈ Set.Ico a (a + p)
Theorem: inf_sup_assoc_of_le
File: Mathlib/Order/ModularLattice.lean

tactic: rw [inf_comm, sup_comm, ← sup_inf_assoc_of_le y h, inf_comm, sup_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
h : z ≤ x
⊢ x ⊓ y ⊔ z = x ⊓ (y ⊔ z)
Theorem: MulChar.mul_one
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: ext
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
⊢ χ * 1 = χ

tactic: simp only [mul_one, Pi.mul_apply, MulChar.coeToFun_mul, MulChar.one_apply_coe]
state_before: case h
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a✝ : Rˣ
⊢ ↑(χ * 1) ↑a✝ = ↑χ ↑a✝
Theorem: Nat.floor_le_ceil
File: Mathlib/Algebra/Order/Floor.lean

tactic: obtain ha | ha := le_total a 0
state_before: F : Type ?u.55586
α : Type u_1
β : Type ?u.55592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ ⌊a⌋₊ ≤ ⌈a⌉₊

tactic: rw [floor_of_nonpos ha]
state_before: case inl
F : Type ?u.55586
α : Type u_1
β : Type ?u.55592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : a ≤ 0
⊢ ⌊a⌋₊ ≤ ⌈a⌉₊

tactic: exact Nat.zero_le _
state_before: case inl
F : Type ?u.55586
α : Type u_1
β : Type ?u.55592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : a ≤ 0
⊢ 0 ≤ ⌈a⌉₊

tactic: exact cast_le.1 ((floor_le ha).trans <| le_ceil _)
state_before: case inr
F : Type ?u.55586
α : Type u_1
β : Type ?u.55592
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
⊢ ⌊a⌋₊ ≤ ⌈a⌉₊
Theorem: CategoryTheory.isIso_of_op
File: Mathlib/CategoryTheory/Opposites.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f.op
⊢ (f ≫ (inv f.op).unop).op = (𝟙 X).op

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f.op
⊢ ((inv f.op).unop ≫ f).op = (𝟙 Y).op
Theorem: CategoryTheory.tensorRightHomEquiv_id_tensor_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorRightHomEquiv, rightAdjointMate]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ ↑(tensorRightHomEquiv Yᘁ X Xᘁ (𝟙_ C)) ((𝟙 Yᘁ ⊗ f) ≫ ε_ Y Yᘁ) = fᘁ ≫ (λ_ Xᘁ).inv

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ (ρ_ Yᘁ).inv ≫ (𝟙 Yᘁ ⊗ η_ X Xᘁ) ≫ (α_ Yᘁ X Xᘁ).inv ≫ ((𝟙 Yᘁ ⊗ f) ≫ ε_ Y Yᘁ ⊗ 𝟙 Xᘁ) =
    ((ρ_ Yᘁ).inv ≫ (𝟙 Yᘁ ⊗ η_ X Xᘁ) ≫ (𝟙 Yᘁ ⊗ f ⊗ 𝟙 Xᘁ) ≫ (α_ Yᘁ Y Xᘁ).inv ≫ (ε_ Y Yᘁ ⊗ 𝟙 Xᘁ) ≫ (λ_ Xᘁ).hom) ≫
      (λ_ Xᘁ).inv
Theorem: Real.Wallis.W_le
File: Mathlib/Data/Real/Pi/Wallis.lean

tactic: rw [← div_le_one pi_div_two_pos, div_eq_inv_mul]
state_before: k : ℕ
⊢ W k ≤ π / 2

tactic: rw [W_eq_integral_sin_pow_div_integral_sin_pow, div_le_one (integral_sin_pow_pos _)]
state_before: k : ℕ
⊢ (π / 2)⁻¹ * W k ≤ 1

tactic: apply integral_sin_pow_succ_le
state_before: k : ℕ
⊢ (∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k + 1)) ≤ ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)
Theorem: Std.RBNode.All.lowerBound?_lb
File: Std/Data/RBMap/Lemmas.lean

tactic: exact H
state_before: case nil
α : Type u_1
p : α → Prop
x : α
cut : α → Ordering
lb : Option α
hp : All p nil
H : ∀ {x : α}, x ∈ lb → p x
⊢ x ∈ lowerBound? cut nil lb → p x

tactic: simp [lowerBound?]
state_before: case node
α : Type u_1
p : α → Prop
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut l✝ lb → p x
ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut r✝ lb → p x
lb : Option α
hp : All p (node c✝ l✝ v✝ r✝)
H : ∀ {x : α}, x ∈ lb → p x
⊢ x ∈ lowerBound? cut (node c✝ l✝ v✝ r✝) lb → p x

tactic: split
state_before: case node
α : Type u_1
p : α → Prop
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut l✝ lb → p x
ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut r✝ lb → p x
lb : Option α
hp : All p (node c✝ l✝ v✝ r✝)
H : ∀ {x : α}, x ∈ lb → p x
⊢ (match cut v✝ with
      | Ordering.lt => lowerBound? cut l✝ lb
      | Ordering.gt => lowerBound? cut r✝ (some v✝)
      | Ordering.eq => some v✝) =
      some x →
    p x

tactic: exact ihl hp.2.1 H
state_before: case node.h_1
α : Type u_1
p : α → Prop
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut l✝ lb → p x
ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut r✝ lb → p x
lb : Option α
hp : All p (node c✝ l✝ v✝ r✝)
H : ∀ {x : α}, x ∈ lb → p x
x✝ : Ordering
heq✝ : cut v✝ = Ordering.lt
⊢ lowerBound? cut l✝ lb = some x → p x

tactic: exact ihr hp.2.2 fun | rfl => hp.1
state_before: case node.h_2
α : Type u_1
p : α → Prop
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut l✝ lb → p x
ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut r✝ lb → p x
lb : Option α
hp : All p (node c✝ l✝ v✝ r✝)
H : ∀ {x : α}, x ∈ lb → p x
x✝ : Ordering
heq✝ : cut v✝ = Ordering.gt
⊢ lowerBound? cut r✝ (some v✝) = some x → p x

tactic: exact fun | rfl => hp.1
state_before: case node.h_3
α : Type u_1
p : α → Prop
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut l✝ lb → p x
ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → x ∈ lowerBound? cut r✝ lb → p x
lb : Option α
hp : All p (node c✝ l✝ v✝ r✝)
H : ∀ {x : α}, x ∈ lb → p x
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
⊢ some v✝ = some x → p x
Theorem: Multiset.prod_int_mod
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: induction s using Multiset.induction <;> simp [Int.mul_emod, *]
state_before: ι : Type ?u.172491
α : Type ?u.172494
β : Type ?u.172497
γ : Type ?u.172500
s : Multiset ℤ
n : ℤ
⊢ prod s % n = prod (map (fun x => x % n) s) % n
Theorem: circleMap_eq_center_iff
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [circleMap, exp_ne_zero]
state_before: E : Type ?u.19739
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ circleMap c R θ = c ↔ R = 0
Theorem: Set.preimage_const_add_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iic]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a + x) ⁻¹' Icc b c = Icc (b - a) (c - a)
Theorem: ZNum.div_zero
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: n : ZNum
⊢ div n 0 = 0
Theorem: FirstOrder.Language.Theory.CompleteType.nonempty_iff
File: Mathlib/ModelTheory/Types.lean

tactic: rw [← isSatisfiable_onTheory_iff (lhomWithConstants_injective L α)]
state_before: L : Language
T : Theory L
α : Type w
⊢ Nonempty (CompleteType T α) ↔ IsSatisfiable T

tactic: rw [nonempty_iff_univ_nonempty, nonempty_iff_ne_empty, Ne.def, not_iff_comm,
  ← union_empty ((L.lhomWithConstants α).onTheory T), ← setOf_subset_eq_empty_iff]
state_before: L : Language
T : Theory L
α : Type w
⊢ Nonempty (CompleteType T α) ↔ IsSatisfiable (LHom.onTheory (lhomWithConstants L α) T)

tactic: simp
state_before: L : Language
T : Theory L
α : Type w
⊢ {p | ∅ ⊆ ↑p} = ∅ ↔ Set.univ = ∅
Theorem: Polynomial.coeff_X_pow_self
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: simp [coeff_X_pow]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ coeff (X ^ n) n = 1
Theorem: List.prod_map_eq_pow_single
File: Mathlib/Data/List/Count.lean

tactic: induction' l with a' as h generalizing a
state_before: α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a : α
f : α → β
hf : ∀ (a' : α), a' ≠ a → a' ∈ l → f a' = 1
⊢ prod (map f l) = f a ^ count a l

tactic: rw [map_nil, prod_nil, count_nil, _root_.pow_zero]
state_before: case nil
α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a✝ : α
f : α → β
hf✝ : ∀ (a' : α), a' ≠ a✝ → a' ∈ l → f a' = 1
a : α
hf : ∀ (a' : α), a' ≠ a → a' ∈ [] → f a' = 1
⊢ prod (map f []) = f a ^ count a []

tactic: specialize h a fun a' ha' hfa' => hf a' ha' (mem_cons_of_mem _ hfa')
state_before: case cons
α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a✝ : α
f : α → β
hf✝ : ∀ (a' : α), a' ≠ a✝ → a' ∈ l → f a' = 1
a' : α
as : List α
h : ∀ (a : α), (∀ (a' : α), a' ≠ a → a' ∈ as → f a' = 1) → prod (map f as) = f a ^ count a as
a : α
hf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1
⊢ prod (map f (a' :: as)) = f a ^ count a (a' :: as)

tactic: rw [List.map_cons, List.prod_cons, count_cons, h]
state_before: case cons
α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a✝ : α
f : α → β
hf✝ : ∀ (a' : α), a' ≠ a✝ → a' ∈ l → f a' = 1
a' : α
as : List α
a : α
hf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1
h : prod (map f as) = f a ^ count a as
⊢ prod (map f (a' :: as)) = f a ^ count a (a' :: as)

tactic: split_ifs with ha'
state_before: case cons
α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a✝ : α
f : α → β
hf✝ : ∀ (a' : α), a' ≠ a✝ → a' ∈ l → f a' = 1
a' : α
as : List α
a : α
hf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1
h : prod (map f as) = f a ^ count a as
⊢ f a' * f a ^ count a as = f a ^ if a = a' then succ (count a as) else count a as

tactic: rw [ha', _root_.pow_succ]
state_before: case cons.inl
α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a✝ : α
f : α → β
hf✝ : ∀ (a' : α), a' ≠ a✝ → a' ∈ l → f a' = 1
a' : α
as : List α
a : α
hf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1
h : prod (map f as) = f a ^ count a as
ha' : a = a'
⊢ f a' * f a ^ count a as = f a ^ succ (count a as)

tactic: rw [hf a' (Ne.symm ha') (List.mem_cons_self a' as), one_mul]
state_before: case cons.inr
α : Type u_2
l : List α
inst✝¹ : DecidableEq α
β : Type u_1
inst✝ : Monoid β
a✝ : α
f : α → β
hf✝ : ∀ (a' : α), a' ≠ a✝ → a' ∈ l → f a' = 1
a' : α
as : List α
a : α
hf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1
h : prod (map f as) = f a ^ count a as
ha' : ¬a = a'
⊢ f a' * f a ^ count a as = f a ^ count a as
Theorem: IsSubmonoid.image
File: Mathlib/Deprecated/Submonoid.lean

tactic: rw [hf.map_mul, hx.2, hy.2]
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.26765
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_1
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
s : Set M
hs : IsSubmonoid s
a b : γ
x✝¹ : a ∈ f '' s
x✝ : b ∈ f '' s
x : M
hx : x ∈ s ∧ f x = a
y : M
hy : y ∈ s ∧ f y = b
⊢ f (x * y) = a * b