tasksource/leandojo huggingface dataset:
Theorem: Matrix.mul_inv_rev
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp only [inv_def]
state_before: l : Type ?u.349525
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
⊢ (A ⬝ B)⁻¹ = B⁻¹ ⬝ A⁻¹

tactic: rw [Matrix.smul_mul, Matrix.mul_smul, smul_smul, det_mul, adjugate_mul_distrib,
  Ring.mul_inverse_rev]
state_before: l : Type ?u.349525
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
⊢ Ring.inverse (det (A ⬝ B)) • adjugate (A ⬝ B) =
    (Ring.inverse (det B) • adjugate B) ⬝ (Ring.inverse (det A) • adjugate A)
Theorem: HasFPowerSeriesOnBall.eventually_eq_zero
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: filter_upwards [hf.eventually_hasSum_sub] with z hz using hz.unique hasSum_zero
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.469661
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f 0 x r
⊢ ∀ᶠ (z : E) in 𝓝 x, f z = 0
Theorem: Set.toFinset_nonempty
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← Finset.coe_nonempty, coe_toFinset]
state_before: α : Type u_1
β : Type ?u.81654
γ : Type ?u.81657
s✝ t s : Set α
inst✝ : Fintype ↑s
⊢ Finset.Nonempty (toFinset s) ↔ Set.Nonempty s
Theorem: Nat.Partrec.Code.encode_lt_pair
File: Mathlib/Computability/PartrecCode.lean

tactic: simp [encodeCode_eq, encodeCode]
state_before: cf cg : Code
⊢ encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg)

tactic: have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 * 2)
state_before: cf cg : Code
⊢ encodeCode cf < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 ∧
    encodeCode cg < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4

tactic: rw [one_mul, mul_assoc] at this
state_before: cf cg : Code
this : 1 * Nat.pair (encodeCode cf) (encodeCode cg) ≤ 2 * 2 * Nat.pair (encodeCode cf) (encodeCode cg)
⊢ encodeCode cf < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 ∧
    encodeCode cg < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4

tactic: have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4))
state_before: cf cg : Code
this : Nat.pair (encodeCode cf) (encodeCode cg) ≤ 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg))
⊢ encodeCode cf < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 ∧
    encodeCode cg < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4

tactic: exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩
state_before: cf cg : Code
this✝ : Nat.pair (encodeCode cf) (encodeCode cg) ≤ 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg))
this : Nat.pair (encodeCode cf) (encodeCode cg) < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4
⊢ encodeCode cf < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 ∧
    encodeCode cg < 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4

tactic: decide
state_before: cf cg : Code
⊢ 1 ≤ 2 * 2

tactic: decide
state_before: cf cg : Code
this : Nat.pair (encodeCode cf) (encodeCode cg) ≤ 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg))
⊢ 0 < 4
Theorem: Set.Infinite.nonempty
File: Mathlib/Data/Set/Finite.lean

tactic: rintro rfl
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
h : Set.Infinite s
⊢ s ≠ ∅

tactic: exact h finite_empty
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
h : Set.Infinite ∅
⊢ False
Theorem: AddCircle.coe_eq_coe_iff_of_mem_Ico
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: refine' ⟨fun h => _, by tauto⟩
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
⊢ ↑x = ↑y ↔ x = y

tactic: suffices (⟨x, hx⟩ : Ico a (a + p)) = ⟨y, hy⟩ by exact Subtype.mk.inj this
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
h : ↑x = ↑y
⊢ x = y

tactic: apply_fun equivIco p a  at h
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
h : ↑x = ↑y
⊢ { val := x, property := hx } = { val := y, property := hy }

tactic: rw [← (equivIco p a).right_inv ⟨x, hx⟩, ← (equivIco p a).right_inv ⟨y, hy⟩]
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
h : ↑(equivIco p a) ↑x = ↑(equivIco p a) ↑y
⊢ { val := x, property := hx } = { val := y, property := hy }

tactic: exact h
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
h : ↑(equivIco p a) ↑x = ↑(equivIco p a) ↑y
⊢ Equiv.toFun (equivIco p a) (Equiv.invFun (equivIco p a) { val := x, property := hx }) =
    Equiv.toFun (equivIco p a) (Equiv.invFun (equivIco p a) { val := y, property := hy })

tactic: tauto
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
⊢ x = y → ↑x = ↑y

tactic: exact Subtype.mk.inj this
state_before: 𝕜 : Type u_1
B : Type ?u.79444
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x y : 𝕜
hx : x ∈ Ico a (a + p)
hy : y ∈ Ico a (a + p)
h : ↑x = ↑y
this : { val := x, property := hx } = { val := y, property := hy }
⊢ x = y
Theorem: GeneralizedContinuedFraction.terminatedAt_iff_s_none
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: rfl
state_before: α : Type u_1
g : GeneralizedContinuedFraction α
n : ℕ
⊢ TerminatedAt g n ↔ Stream'.Seq.get? g.s n = none
Theorem: Nat.sub_add_min_cancel
File: Std/Data/Nat/Lemmas.lean

tactic: rw [sub_eq_sub_min, Nat.sub_add_cancel (Nat.min_le_left n m)]
state_before: n m : Nat
⊢ n - m + min n m = n
Theorem: IsLocalization.surj''
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

tactic: rcases IsLocalization.surj M z with ⟨⟨r, m⟩, e : z * _ = algebraMap R S r⟩
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.160993
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
z : S
⊢ ∃ r m, z = r • ↑(↑(toInvSubmonoid M S) m)

tactic: refine' ⟨r, m, _⟩
state_before: case intro.mk
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.160993
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
z : S
r : R
m : { x // x ∈ M }
e : z * ↑(algebraMap R S) ↑(r, m).snd = ↑(algebraMap R S) r
⊢ ∃ r m, z = r • ↑(↑(toInvSubmonoid M S) m)

tactic: rw [Algebra.smul_def, ← e, mul_assoc]
state_before: case intro.mk
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.160993
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
z : S
r : R
m : { x // x ∈ M }
e : z * ↑(algebraMap R S) ↑(r, m).snd = ↑(algebraMap R S) r
⊢ z = r • ↑(↑(toInvSubmonoid M S) m)

tactic: simp
state_before: case intro.mk
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.160993
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
z : S
r : R
m : { x // x ∈ M }
e : z * ↑(algebraMap R S) ↑(r, m).snd = ↑(algebraMap R S) r
⊢ z = z * (↑(algebraMap R S) ↑(r, m).snd * ↑(↑(toInvSubmonoid M S) m))
Theorem: PowerSeries.span_X_isPrime
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: suffices Ideal.span ({X} : Set (PowerSeries R)) = RingHom.ker (constantCoeff R) by
  rw [this]
  exact RingHom.ker_isPrime _
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ Ideal.IsPrime (Ideal.span {X})

tactic: apply Ideal.ext
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ Ideal.span {X} = RingHom.ker (constantCoeff R)

tactic: intro φ
state_before: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ ∀ (x : PowerSeries R), x ∈ Ideal.span {X} ↔ x ∈ RingHom.ker (constantCoeff R)

tactic: rw [RingHom.mem_ker, Ideal.mem_span_singleton, X_dvd_iff]
state_before: case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
φ : PowerSeries R
⊢ φ ∈ Ideal.span {X} ↔ φ ∈ RingHom.ker (constantCoeff R)

tactic: rw [this]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
this : Ideal.span {X} = RingHom.ker (constantCoeff R)
⊢ Ideal.IsPrime (Ideal.span {X})

tactic: exact RingHom.ker_isPrime _
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
this : Ideal.span {X} = RingHom.ker (constantCoeff R)
⊢ Ideal.IsPrime (RingHom.ker (constantCoeff R))
Theorem: Decidable.iff_iff_not_or_and_or_not
File: Std/Logic.lean

tactic: rw [iff_iff_implies_and_implies a b]
state_before: a b : Prop
inst✝¹ : Decidable a
inst✝ : Decidable b
⊢ (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b)

tactic: simp only [imp_iff_not_or, Or.comm]
state_before: a b : Prop
inst✝¹ : Decidable a
inst✝ : Decidable b
⊢ (a → b) ∧ (b → a) ↔ (¬a ∨ b) ∧ (a ∨ ¬b)
Theorem: MvPolynomial.pderiv_monomial_single
File: Mathlib/Data/MvPolynomial/PDeriv.lean

tactic: simp
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i : σ
n : ℕ
⊢ ↑(pderiv i) (↑(monomial (single i n)) a) = ↑(monomial (single i (n - 1))) (a * ↑n)
Theorem: inf_covby_of_covby_sup_of_covby_sup_right
File: Mathlib/Order/ModularLattice.lean

tactic: rw [sup_comm, inf_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakLowerModularLattice α
a b : α
⊢ a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ b

tactic: exact fun ha hb => inf_covby_of_covby_sup_of_covby_sup_left hb ha
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakLowerModularLattice α
a b : α
⊢ a ⋖ b ⊔ a → b ⋖ b ⊔ a → b ⊓ a ⋖ b
Theorem: PFun.fix_fwd_eq
File: Mathlib/Data/PFun.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
⊢ fix f a = fix f a'

tactic: constructor
state_before: case H
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
⊢ b ∈ fix f a ↔ b ∈ fix f a'

tactic: intro h
state_before: case H.mp
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
⊢ b ∈ fix f a → b ∈ fix f a'

tactic: obtain h' | ⟨a, h', e'⟩ := mem_fix_iff.1 h <;> cases Part.mem_unique ha' h'
state_before: case H.mp
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
h : b ∈ fix f a
⊢ b ∈ fix f a'

tactic: exact e'
state_before: case H.mp.inr.intro.intro.refl
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
h : b ∈ fix f a
h' : Sum.inr a' ∈ f a
e' : b ∈ fix f a'
⊢ b ∈ fix f a'

tactic: intro h
state_before: case H.mpr
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
⊢ b ∈ fix f a' → b ∈ fix f a

tactic: rw [PFun.mem_fix_iff]
state_before: case H.mpr
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
h : b ∈ fix f a'
⊢ b ∈ fix f a

tactic: exact Or.inr ⟨a', ha', h⟩
state_before: case H.mpr
α : Type u_1
β : Type u_2
γ : Type ?u.29936
δ : Type ?u.29939
ε : Type ?u.29942
ι : Type ?u.29945
f : α →. β ⊕ α
a a' : α
ha' : Sum.inr a' ∈ f a
b : β
h : b ∈ fix f a'
⊢ Sum.inl b ∈ f a ∨ ∃ a', Sum.inr a' ∈ f a ∧ b ∈ fix f a'
Theorem: Real.rpow_def_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def, Complex.cpow_def, if_neg]
state_before: x : ℝ
hx : x < 0
y : ℝ
⊢ x ^ y = exp (log x * y) * cos (y * π)

tactic: have : Complex.log x * y = ↑(log (-x) * y) + ↑(y * π) * Complex.I := by
  simp only [Complex.log, abs_of_neg hx, Complex.arg_ofReal_of_neg hx, Complex.abs_ofReal,
    Complex.ofReal_mul]
  ring
state_before: x : ℝ
hx : x < 0
y : ℝ
⊢ (Complex.exp (Complex.log ↑x * ↑y)).re = exp (log x * y) * cos (y * π)

case hnc
x : ℝ
hx : x < 0
y : ℝ
⊢ ¬↑x = 0

tactic: simp only [Complex.log, abs_of_neg hx, Complex.arg_ofReal_of_neg hx, Complex.abs_ofReal,
  Complex.ofReal_mul]
state_before: x : ℝ
hx : x < 0
y : ℝ
⊢ Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I

tactic: ring
state_before: x : ℝ
hx : x < 0
y : ℝ
⊢ (↑(log (-x)) + ↑π * Complex.I) * ↑y = ↑(log (-x)) * ↑y + ↑y * ↑π * Complex.I

tactic: rw [this, Complex.exp_add_mul_I, ← Complex.ofReal_exp, ← Complex.ofReal_cos, ←
  Complex.ofReal_sin, mul_add, ← Complex.ofReal_mul, ← mul_assoc, ← Complex.ofReal_mul,
  Complex.add_re, Complex.ofReal_re, Complex.mul_re, Complex.I_re, Complex.ofReal_im,
  Real.log_neg_eq_log]
state_before: x : ℝ
hx : x < 0
y : ℝ
this : Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
⊢ (Complex.exp (Complex.log ↑x * ↑y)).re = exp (log x * y) * cos (y * π)

tactic: ring
state_before: x : ℝ
hx : x < 0
y : ℝ
this : Complex.log ↑x * ↑y = ↑(log (-x) * y) + ↑(y * π) * Complex.I
⊢ exp (log x * y) * cos (y * π) + ((↑(exp (log x * y) * sin (y * π))).re * 0 - 0 * Complex.I.im) =
    exp (log x * y) * cos (y * π)

tactic: rw [Complex.ofReal_eq_zero]
state_before: case hnc
x : ℝ
hx : x < 0
y : ℝ
⊢ ¬↑x = 0

tactic: exact ne_of_lt hx
state_before: case hnc
x : ℝ
hx : x < 0
y : ℝ
⊢ ¬x = 0
Theorem: sbtw_const_vsub_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Sbtw, Sbtw, wbtw_const_vsub_iff, (vsub_right_injective p).ne_iff,
  (vsub_right_injective p).ne_iff]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.124810
P : Type u_3
P' : Type ?u.124816
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p : P
⊢ Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z
Theorem: StrictAnti.prod_map
File: Mathlib/Order/Monotone/Basic.lean

tactic: simp only [Prod.lt_iff]
state_before: ι : Type ?u.48700
α : Type u
β : Type v
γ : Type w
δ : Type u_1
π : ι → Type ?u.48714
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictAnti f
hg : StrictAnti g
a b : α × β
⊢ a < b → Prod.map f g b < Prod.map f g a

tactic: exact Or.imp (And.imp hf.imp hg.antitone.imp) (And.imp hf.antitone.imp hg.imp)
state_before: ι : Type ?u.48700
α : Type u
β : Type v
γ : Type w
δ : Type u_1
π : ι → Type ?u.48714
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictAnti f
hg : StrictAnti g
a b : α × β
⊢ a.fst < b.fst ∧ a.snd ≤ b.snd ∨ a.fst ≤ b.fst ∧ a.snd < b.snd →
    (Prod.map f g b).fst < (Prod.map f g a).fst ∧ (Prod.map f g b).snd ≤ (Prod.map f g a).snd ∨
      (Prod.map f g b).fst ≤ (Prod.map f g a).fst ∧ (Prod.map f g b).snd < (Prod.map f g a).snd
Theorem: CategoryTheory.SimplicialObject.augment_hom_zero
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp
state_before: C : Type u
inst✝ : Category C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj [0].op ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ (augment X X₀ f w).hom.app [0].op = f

tactic: rw [SimplexCategory.hom_zero_zero ([0].const 0), op_id, X.map_id, Category.id_comp]
state_before: C : Type u
inst✝ : Category C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj [0].op ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ X.map (SimplexCategory.const [0] 0).op ≫ f = f
Theorem: Finset.sigma_eq_biUnion
File: Mathlib/Data/Finset/Sigma.lean

tactic: ext ⟨x, y⟩
state_before: ι : Type u_2
α : ι → Type u_1
β : Type ?u.9726
s✝ s₁ s₂ : Finset ι
t✝ t₁ t₂ : (i : ι) → Finset (α i)
inst✝ : DecidableEq ((i : ι) × α i)
s : Finset ι
t : (i : ι) → Finset (α i)
⊢ Finset.sigma s t = Finset.biUnion s fun i => map (Embedding.sigmaMk i) (t i)

tactic: simp [and_left_comm]
state_before: case a.mk
ι : Type u_2
α : ι → Type u_1
β : Type ?u.9726
s✝ s₁ s₂ : Finset ι
t✝ t₁ t₂ : (i : ι) → Finset (α i)
inst✝ : DecidableEq ((i : ι) × α i)
s : Finset ι
t : (i : ι) → Finset (α i)
x : ι
y : α x
⊢ { fst := x, snd := y } ∈ Finset.sigma s t ↔
    { fst := x, snd := y } ∈ Finset.biUnion s fun i => map (Embedding.sigmaMk i) (t i)
Theorem: Submonoid.coe_iSup_of_directed
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: M : Type u_2
A : Type ?u.34491
B : Type ?u.34494
inst✝¹ : MulOneClass M
ι : Sort u_1
inst✝ : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(⨆ (i : ι), S i) ↔ x ∈ ⋃ (i : ι), ↑(S i)
Theorem: IsPreconnected.Icc_subset
File: Mathlib/Topology/Algebra/Order/IntermediateValue.lean

tactic: simpa only [image_id] using hs.intermediate_value ha hb continuousOn_id
state_before: X : Type u
α : Type v
inst✝³ : TopologicalSpace X
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
s : Set α
hs : IsPreconnected s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ Icc a b ⊆ s
Theorem: FermatPsp.probablePrime_iff_modEq
File: Mathlib/NumberTheory/FermatPsp.lean

tactic: have : 1 ≤ b ^ (n - 1) := one_le_pow_of_one_le h (n - 1)
state_before: n b : ℕ
h : 1 ≤ b
⊢ ProbablePrime n b ↔ b ^ (n - 1) ≡ 1 [MOD n]

tactic: rw [Nat.ModEq.comm]
state_before: n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
⊢ ProbablePrime n b ↔ b ^ (n - 1) ≡ 1 [MOD n]

tactic: constructor
state_before: n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
⊢ ProbablePrime n b ↔ 1 ≡ b ^ (n - 1) [MOD n]

tactic: intro h₁
state_before: case mp
n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
⊢ ProbablePrime n b → 1 ≡ b ^ (n - 1) [MOD n]

tactic: apply Nat.modEq_of_dvd
state_before: case mp
n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
h₁ : ProbablePrime n b
⊢ 1 ≡ b ^ (n - 1) [MOD n]

tactic: exact_mod_cast h₁
state_before: case mp.a
n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
h₁ : ProbablePrime n b
⊢ ↑n ∣ ↑(b ^ (n - 1)) - ↑1

tactic: intro h₁
state_before: case mpr
n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
⊢ 1 ≡ b ^ (n - 1) [MOD n] → ProbablePrime n b

tactic: exact_mod_cast Nat.ModEq.dvd h₁
state_before: case mpr
n b : ℕ
h : 1 ≤ b
this : 1 ≤ b ^ (n - 1)
h₁ : 1 ≡ b ^ (n - 1) [MOD n]
⊢ ProbablePrime n b
Theorem: Matrix.add_vecMul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.857786
m : Type u_1
n : Type u_2
o : Type ?u.857795
m' : o → Type ?u.857800
n' : o → Type ?u.857805
R : Type ?u.857808
S : Type ?u.857811
α : Type v
β : Type w
γ : Type ?u.857818
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A : Matrix m n α
x y : m → α
⊢ vecMul (x + y) A = vecMul x A + vecMul y A

tactic: apply add_dotProduct
state_before: case h
l : Type ?u.857786
m : Type u_1
n : Type u_2
o : Type ?u.857795
m' : o → Type ?u.857800
n' : o → Type ?u.857805
R : Type ?u.857808
S : Type ?u.857811
α : Type v
β : Type w
γ : Type ?u.857818
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A : Matrix m n α
x y : m → α
x✝ : n
⊢ vecMul (x + y) A x✝ = (vecMul x A + vecMul y A) x✝
Theorem: GroupCat.SurjectiveOfEpiAuxs.fromCoset_ne_of_nin_range
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: intro r
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
⊢ fromCoset
      { val := b *l (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                b *l (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) } ≠
    fromCoset
      { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }

tactic: simp only [fromCoset.injEq, Subtype.mk.injEq] at r
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
r :
  fromCoset
      { val := b *l (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                b *l (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) } =
    fromCoset
      { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }
⊢ False

tactic: let b' : B.α := b
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
r : b *l (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier = (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier
⊢ False

tactic: change b' *l f.range = f.range at r
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
r : b *l (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier = (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier
b' : ↑B := b
⊢ False

tactic: nth_rw 2 [show (f.range : Set B.α) = 1 *l f.range from (one_leftCoset _).symm] at r
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
b' : ↑B := b
r : b' *l ↑(MonoidHom.range f) = ↑(MonoidHom.range f)
⊢ False

tactic: rw [leftCoset_eq_iff, mul_one] at r
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
b' : ↑B := b
r : b' *l ↑(MonoidHom.range f) = 1 *l ↑(MonoidHom.range f)
⊢ False

tactic: exact hb (inv_inv b ▸ Subgroup.inv_mem _ r)
state_before: A B : GroupCat
f : A ⟶ B
b : ↑B
hb : ¬b ∈ MonoidHom.range f
b' : ↑B := b
r : b'⁻¹ ∈ MonoidHom.range f
⊢ False
Theorem: List.pairwise_singleton
File: Mathlib/Data/List/Pairwise.lean

tactic: simp [Pairwise.nil]
state_before: α : Type u_1
β : Type ?u.7483
R✝ S T : α → α → Prop
a✝ : α
l : List α
R : α → α → Prop
a : α
⊢ Pairwise R [a]
Theorem: LinearMap.inr_map_mul
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp
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.152136
M₆ : Type ?u.152139
S : Type ?u.152142
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₂
A : Type u_1
inst✝³ : NonUnitalNonAssocSemiring A
inst✝² : Module R A
B : Type u_2
inst✝¹ : NonUnitalNonAssocSemiring B
inst✝ : Module R B
b₁ b₂ : B
⊢ (↑(inr R A B) (b₁ * b₂)).fst = (↑(inr R A B) b₁ * ↑(inr R A B) b₂).fst